Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract AtomicTypes
•  contract AtomicUtils
•    - function balanceOf(Token token)
•    - function send(Token token, address pa ...
•    - function claimTokenFromSenderTo(Token ...
•    - function approve(Token _token, addres ...
•    - function validateOptionalERC20Return( ...
•    - function isETH(Token token)
•    - function isWETH(Token token)
•    - function sliceBytes(
•  contract AtomicModuleRegistry
•    - function setNewRegistrar(address newR ...
•    - function registerModule(address modul ...
•    - function swap(
•  contract AtomicBlue is AtomicUtils ... *
•    - function swapAndSend(
•    - function multiPathSwapAndSend(
•    - function doDistributedSwap(
•    - function swap(
•    - function multiPathSwap(
•  contract AtomicTokenProxy is Atomi ...
•    - function swapAndSend(
•    - function multiPathSwapAndSend(
•    - function swap(
•    - function swapWithGasTokens(
•    - function multiPathSwap(
•    - function multiPathSwapWithGasTokens(
•    - function swapAndSendWithGasTokens(
•    - function multiPathSwapAndSendWithGasT ...
•  contract Token
•    - function totalSupply()
•    - function balanceOf(address _owner)
•    - function transfer(address _to, uint25 ...
•    - function transferFrom(address _from, ...
•    - function approve(address _spender, ui ...
•    - function allowance(address _owner, ad ...
•  contract IWETH is Token
•    - function deposit()
•    - function withdraw(uint256 amount)
•  contract IGasToken
•    - function freeUpTo(uint256 value)
•    - function free(uint256 value)
•    - function freeFrom(address from, uint2 ...
•    - function freeFromUpTo(address from, u ...

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-02-12
*/

pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;

contract AtomicTypes{
    struct SwapParams{
        Token sellToken; 
        uint256 input;
        Token buyToken;
        uint minOutput;
    }
    
    struct DistributionParams{
        IAtomicExchange[] exchangeModules;
        bytes[] exchangeData;
        uint256[] chunks;
    }
    
    event Trade(
        address indexed sellToken,
        uint256 sellAmount,
        address indexed buyToken,
        uint256 buyAmount,
        address indexed trader,
        address receiver
    );
}

contract AtomicUtils{    
    // ETH and its wrappers
    address constant WETHAddress = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    IWETH constant WETH = IWETH(WETHAddress);
    Token constant ETH = Token(address(0));
    address constant EEEAddress = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    Token constant EEE = Token(EEEAddress);
    
    // Universal function to query this contracts balance, supporting  and Token
    function balanceOf(Token token) internal view returns(uint balance){
        if(isETH(token)){
            return address(this).balance;
        }else{
            return token.balanceOf(address(this));
        }
    }
    
    // Universal send function, supporting ETH and Token
    function send(Token token, address payable recipient, uint amount) internal {
        if(isETH(token)){
            require(
                recipient.send(amount),
                "Sending of ETH failed."
            );
        }else{
            Token(token).transfer(recipient, amount);
            require(
                validateOptionalERC20Return(),
                "ERC20 token transfer failed."
            );
        }
    }
    
    // Universal function to claim tokens from msg.sender
    function claimTokenFromSenderTo(Token _token, uint _amount, address _receiver) internal {
        if (isETH(_token)) {
            require(msg.value == _amount);
            // dont forward ETH
        }else{
            require(msg.value  == 0);
            _token.transferFrom(msg.sender, _receiver, _amount);
        }
    }
    
    // Token approval function supporting non-compliant tokens
    function approve(Token _token, address _spender, uint _amount) internal {
        if (!isETH(_token)) {
            _token.approve(_spender, _amount);
            require(
                validateOptionalERC20Return(),
                "ERC20 approval failed."
            );
        }
    }
    
    // Validate return data of non-compliant erc20s
    function validateOptionalERC20Return() pure internal returns (bool){
        uint256 success = 0;

        assembly {
            switch returndatasize()             // Check the number of bytes the token contract returned
            case 0 {                            // Nothing returned, but contract did not throw > assume our transfer succeeded
                success := 1
            }
            case 32 {                           // 32 bytes returned, result is the returned bool
                returndatacopy(0, 0, 32)
                success := mload(0)
            }
        }

        return success != 0;
    }

    function isETH(Token token) pure internal  returns (bool){
        if(
            address(token) == address(0)
            || address(token) == EEEAddress
        ){
            return true;
        }else{
            return false;
        }
    }

    function isWETH(Token token) pure internal  returns (bool){
        if(address(token) == WETHAddress){
            return true;
        }else{
            return false;
        }
    }
    
    // Source: https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol
    function sliceBytes(
        bytes memory _bytes,
        uint256 _start,
        uint256 _length
    )
    internal
    pure
    returns (bytes memory)
    {
        require(_bytes.length >= (_start + _length), "Read out of bounds");

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
                tempBytes := mload(0x40)

            // The first word of the slice result is potentially a partial
            // word read from the original array. To read it, we calculate
            // the length of that partial word and start copying that many
            // bytes into the array. The first word we copy will start with
            // data we don't care about, but the last `lengthmod` bytes will
            // land at the beginning of the contents of the new array. When
            // we're done copying, we overwrite the full first word with
            // the actual length of the slice.
                let lengthmod := and(_length, 31)

            // The multiplication in the next line is necessary
            // because when slicing multiples of 32 bytes (lengthmod == 0)
            // the following copy loop was copying the origin's length
            // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                // The multiplication in the next line has the same exact purpose
                // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

            //update free-memory pointer
            //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }
}

contract AtomicModuleRegistry {
    address moduleRegistrar;
    mapping(address => bool) public isModule;
    
    constructor () public {
        moduleRegistrar = msg.sender;
    }

    modifier onlyRegistrar() {
        require(moduleRegistrar == msg.sender, "caller is not moduleRegistrar");
        _;
    }
    
    function setNewRegistrar(address newRegistrar) public virtual onlyRegistrar {
        moduleRegistrar = newRegistrar;
    }
    
    function registerModule(address module, bool status) public virtual onlyRegistrar {
        isModule[module] = status;
    }
}

abstract contract IAtomicExchange is AtomicTypes{
    function swap(
        SwapParams memory _swap,
        bytes memory data
    )  external payable virtual returns(
        uint output
    );
}

contract AtomicBlue is AtomicUtils, AtomicTypes, AtomicModuleRegistry{
    // IMPORTANT NOTICE:
    // NEVER set a token allowance to this contract, as everybody can do arbitrary calls from it.
    // When swapping tokens always go through AtomicTokenProxy.
    // This contract assumes token to swap has already been transfered to it when being called. Ether can be sent directly with the call.

    // perform a distributed swap and transfer outcome to _receipient
    function swapAndSend(
        SwapParams memory _swap,
        
        DistributionParams memory _distribution,
        
        address payable _receipient
    ) public payable returns (uint _output){
        // execute swaps on behalf of trader
        _output = doDistributedSwap(_swap, _distribution);

        // check if output of swap is sufficient        
        require(_output >= _swap.minOutput, "Slippage limit exceeded.");
        
        // send swap output to receipient
        send(_swap.buyToken, _receipient, _output);
        
        emit Trade(
            address(_swap.sellToken),
            _swap.input,
            address(_swap.buyToken),
            _output,
            msg.sender,
            _receipient
        );
    }
    
    function multiPathSwapAndSend(
        SwapParams memory _swap,
        
        Token[] calldata _path,
        
        DistributionParams[] memory _distribution,
        
        address payable _receipient
    ) public payable returns (uint _output){
        // verify path
        require(
            _path[0] == _swap.sellToken
            && _path[_path.length - 1] == _swap.buyToken
            && _path.length >= 2
        );
        
        // execute swaps on behalf of trader
        _output = _swap.input;
        for(uint i = 1; i < _path.length; i++){
            _output = doDistributedSwap(SwapParams({
                sellToken : _path[i - 1],
                input     : _output,      // output of last swap is input for this one
                buyToken  : _path[i],
                minOutput : 0            // we check the total outcome in the end
            }), _distribution[i - 1]);
        }

        // check if output of swap is sufficient        
        require(_output >= _swap.minOutput, "Slippage limit exceeded.");
        
        // send swap output to sender
        send(_swap.buyToken, _receipient, _output);
        
        emit Trade(
            address(_swap.sellToken),
            _swap.input,
            address(_swap.buyToken),
            _output,
            msg.sender,
            _receipient
        );
    }
    
    
    // internal function to perform a distributed swap
    function doDistributedSwap(
        SwapParams memory _swap,
        
        DistributionParams memory _distribution
    ) internal returns(uint){
        
        // count totalChunks
        uint totalChunks = 0;
        for(uint i = 0; i < _distribution.chunks.length; i++){
            totalChunks += _distribution.chunks[i];   
        }
        
        // route trades to the different exchanges
        for(uint i = 0; i < _distribution.exchangeModules.length; i++){
            IAtomicExchange exchange = _distribution.exchangeModules[i];
            
            uint thisInput = _swap.input * _distribution.chunks[i] / totalChunks;
            
            if(address(exchange) == address(0)){
                // trade is not using an exchange module but a direct call
                (address target, uint value, bytes memory callData) = abi.decode(_distribution.exchangeData[i], (address, uint, bytes));
                
                (bool success, bytes memory data) = address(target).call.value(value)(callData);
            
                require(success, "Exchange call reverted.");
            }else{
                // delegate call to the exchange module
                require(isModule[address(exchange)], "unknown exchangeModule");
                (bool success, bytes memory data) = address(exchange).delegatecall(
                    abi.encodePacked(// This encodes the function to call and the parameters we are passing to the settlement function
                        exchange.swap.selector, 
                        abi.encode(
                            SwapParams({
                                sellToken : _swap.sellToken,
                                input     : thisInput,
                                buyToken  : _swap.buyToken,
                                minOutput : 1 // we are checking the combined output in the end
                            }),
                            _distribution.exchangeData[i]
                        )
                    )
                );
            
                require(success, "Exchange module reverted.");
            }
        }
        
        return balanceOf(_swap.buyToken);
    }
    
    // perform a distributed swap
    function swap(
        SwapParams memory _swap,
        DistributionParams memory _distribution
    ) public payable returns (uint _output){
        return swapAndSend(_swap, _distribution, msg.sender);
    }
    
    // perform a multi-path distributed swap
    function multiPathSwap(
        SwapParams memory _swap,
        Token[] calldata _path,
        DistributionParams[] memory _distribution
    ) public payable returns (uint _output){
        return multiPathSwapAndSend(_swap, _path, _distribution, msg.sender);
    }

    // allow ETH receivals
    receive() external payable {}
}

contract AtomicTokenProxy is AtomicUtils, AtomicTypes{
    AtomicBlue constant atomic = AtomicBlue(0x0);

    // perform a distributed swap and transfer outcome to _receipient
    function swapAndSend(
        SwapParams calldata _swap,
        
        DistributionParams calldata _distribution,
        
        address payable _receipient
    ) public payable returns (uint _output){
        // deposit tokens to executor
        claimTokenFromSenderTo(_swap.sellToken, _swap.input, address(atomic));
        
        // execute swaps on behalf of sender
        _output = atomic.swapAndSend.value(msg.value)(_swap, _distribution, _receipient);
    }
    
    // perform a multi-path distributed swap and transfer outcome to _receipient
    function multiPathSwapAndSend(
        SwapParams calldata _swap,
        
        Token[] calldata _path,
        
        DistributionParams[] calldata _distribution,
        
        address payable _receipient
    ) public payable returns (uint _output){
        // deposit tokens to executor
        claimTokenFromSenderTo(_swap.sellToken, _swap.input, address(atomic));
        
        // execute swaps on behalf of sender
        _output = atomic.multiPathSwapAndSend.value(msg.value)(
            _swap,
            _path,
            _distribution,
            _receipient
        );
    }
    
    // perform a distributed swap
    function swap(
        SwapParams calldata _swap,
        DistributionParams calldata _distribution
    ) public payable returns (uint _output){
        return swapAndSend(_swap, _distribution, msg.sender);
    }
    
    // perform a distributed swap and burn optimal gastoken amount afterwards
    function swapWithGasTokens(
        SwapParams calldata _swap,
        DistributionParams calldata _distribution,
        IGasToken _gasToken,
        uint _gasQtyPerToken
    ) public payable returns (uint _output){
        uint startGas = gasleft();
        _output = swapAndSend(_swap, _distribution, msg.sender);
        _gasToken.freeFromUpTo(msg.sender, (startGas - gasleft() + 25000) / _gasQtyPerToken);
    }
    
    // perform a multi-path distributed swap
    function multiPathSwap(
        SwapParams calldata _swap,
        Token[] calldata _path,
        DistributionParams[] calldata _distribution
    ) public payable returns (uint _output){
        return multiPathSwapAndSend(_swap, _path, _distribution, msg.sender);
    }
    
    // perform a multi-path distributed swap and burn optimal gastoken amount afterwards
    function multiPathSwapWithGasTokens(
        SwapParams calldata _swap,
        Token[] calldata _path,
        DistributionParams[] calldata _distribution,
        IGasToken _gasToken,
        uint _gasQtyPerToken
    ) public payable returns (uint _output){
        uint startGas = gasleft();
        _output = multiPathSwapAndSend(_swap, _path, _distribution, msg.sender);
        _gasToken.freeFromUpTo(msg.sender, (startGas - gasleft() + 25000) / _gasQtyPerToken);
    }
    
    // perform a distributed swap, send outcome to _receipient and burn optimal gastoken amount afterwards
    function swapAndSendWithGasTokens(
        SwapParams calldata _swap,
        DistributionParams calldata _distribution,
        address payable _receipient,
        IGasToken _gasToken,
        uint _gasQtyPerToken
    ) public payable returns (uint _output){
        uint startGas = gasleft();
        _output = swapAndSend(_swap, _distribution, _receipient);
        _gasToken.freeFromUpTo(msg.sender, (startGas - gasleft() + 25000) / _gasQtyPerToken);
    }
    
    // perform a multi-path distributed swap, send outcome to _receipient and burn optimal gastoken amount afterwards
    function multiPathSwapAndSendWithGasTokens(
        SwapParams calldata _swap,
        Token[] calldata _path,
        DistributionParams[] calldata _distribution,
        address payable _receipient,
        IGasToken _gasToken,
        uint _gasQtyPerToken
    ) public payable returns (uint _output){
        uint startGas = gasleft();
        _output = multiPathSwapAndSend(_swap, _path, _distribution, _receipient);
        _gasToken.freeFromUpTo(msg.sender, (startGas - gasleft() + 25000) / _gasQtyPerToken);
    }
}

// Interfaces

contract Token {
    function totalSupply() view public returns (uint256 supply) {}

    function balanceOf(address _owner) view public returns (uint256 balance) {}

    function transfer(address _to, uint256 _value) public {}

    function transferFrom(address _from, address _to, uint256 _value)  public {}

    function approve(address _spender, uint256 _value) public {}

    function allowance(address _owner, address _spender) view public returns (uint256 remaining) {}

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

    uint256 public decimals;
    string public name;
}

contract IWETH is Token {
    function deposit() public payable {}

    function withdraw(uint256 amount) public {}
}

contract IGasToken {
    function freeUpTo(uint256 value) public returns (uint256) {
    }

    function free(uint256 value) public returns (uint256) {
    }
    
    function freeFrom(address from, uint256 value) public returns (uint256) {
    }

    function freeFromUpTo(address from, uint256 value) public returns (uint256) {
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sellToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"sellAmount","type":"uint256"},{"indexed":true,"internalType":"address","name":"buyToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"buyAmount","type":"uint256"},{"indexed":true,"internalType":"address","name":"trader","type":"address"},{"indexed":false,"internalType":"address","name":"receiver","type":"address"}],"name":"Trade","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isModule","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"contract Token","name":"sellToken","type":"address"},{"internalType":"uint256","name":"input","type":"uint256"},{"internalType":"contract Token","name":"buyToken","type":"address"},{"internalType":"uint256","name":"minOutput","type":"uint256"}],"internalType":"struct AtomicTypes.SwapParams","name":"_swap","type":"tuple"},{"internalType":"contract Token[]","name":"_path","type":"address[]"},{"components":[{"internalType":"contract IAtomicExchange[]","name":"exchangeModules","type":"address[]"},{"internalType":"bytes[]","name":"exchangeData","type":"bytes[]"},{"internalType":"uint256[]","name":"chunks","type":"uint256[]"}],"internalType":"struct AtomicTypes.DistributionParams[]","name":"_distribution","type":"tuple[]"}],"name":"multiPathSwap","outputs":[{"internalType":"uint256","name":"_output","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"contract Token","name":"sellToken","type":"address"},{"internalType":"uint256","name":"input","type":"uint256"},{"internalType":"contract Token","name":"buyToken","type":"address"},{"internalType":"uint256","name":"minOutput","type":"uint256"}],"internalType":"struct AtomicTypes.SwapParams","name":"_swap","type":"tuple"},{"internalType":"contract Token[]","name":"_path","type":"address[]"},{"components":[{"internalType":"contract IAtomicExchange[]","name":"exchangeModules","type":"address[]"},{"internalType":"bytes[]","name":"exchangeData","type":"bytes[]"},{"internalType":"uint256[]","name":"chunks","type":"uint256[]"}],"internalType":"struct AtomicTypes.DistributionParams[]","name":"_distribution","type":"tuple[]"},{"internalType":"address payable","name":"_receipient","type":"address"}],"name":"multiPathSwapAndSend","outputs":[{"internalType":"uint256","name":"_output","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"registerModule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRegistrar","type":"address"}],"name":"setNewRegistrar","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"contract Token","name":"sellToken","type":"address"},{"internalType":"uint256","name":"input","type":"uint256"},{"internalType":"contract Token","name":"buyToken","type":"address"},{"internalType":"uint256","name":"minOutput","type":"uint256"}],"internalType":"struct AtomicTypes.SwapParams","name":"_swap","type":"tuple"},{"components":[{"internalType":"contract IAtomicExchange[]","name":"exchangeModules","type":"address[]"},{"internalType":"bytes[]","name":"exchangeData","type":"bytes[]"},{"internalType":"uint256[]","name":"chunks","type":"uint256[]"}],"internalType":"struct AtomicTypes.DistributionParams","name":"_distribution","type":"tuple"}],"name":"swap","outputs":[{"internalType":"uint256","name":"_output","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"contract Token","name":"sellToken","type":"address"},{"internalType":"uint256","name":"input","type":"uint256"},{"internalType":"contract Token","name":"buyToken","type":"address"},{"internalType":"uint256","name":"minOutput","type":"uint256"}],"internalType":"struct AtomicTypes.SwapParams","name":"_swap","type":"tuple"},{"components":[{"internalType":"contract IAtomicExchange[]","name":"exchangeModules","type":"address[]"},{"internalType":"bytes[]","name":"exchangeData","type":"bytes[]"},{"internalType":"uint256[]","name":"chunks","type":"uint256[]"}],"internalType":"struct AtomicTypes.DistributionParams","name":"_distribution","type":"tuple"},{"internalType":"address payable","name":"_receipient","type":"address"}],"name":"swapAndSend","outputs":[{"internalType":"uint256","name":"_output","type":"uint256"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

7203:5646:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7681:779;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6725:125;;;;;;;;;;-1:-1:-1;6725:125:0;;;;;:::i;:::-;;:::i;:::-;;6456:40;;;;;;;;;;-1:-1:-1;6456:40:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;6862:126::-;;;;;;;;;;-1:-1:-1;6862:126:0;;;;;:::i;:::-;;:::i;8472:1405::-;;;;;;:::i;:::-;;:::i;12508:273::-;;;;;;:::i;:::-;;:::i;12237:213::-;;;;;;:::i;:::-;;:::i;7681:779::-;7875:12;7955:39;7973:5;7980:13;7955:17;:39::i;:::-;7945:49;;8084:5;:15;;;8073:7;:26;;8065:63;;;;-1:-1:-1;;;8065:63:0;;;;;;;:::i;:::-;;;;;;;;;8192:42;8197:5;:14;;;8213:11;8226:7;8192:4;:42::i;:::-;8405:10;-1:-1:-1;;;;;8260:192:0;8353:5;:14;;;-1:-1:-1;;;;;8260:192:0;8288:5;:15;;;-1:-1:-1;;;;;8260:192:0;;8319:5;:11;;;8383:7;8430:11;8260:192;;;;;;;;:::i;:::-;;;;;;;;7681:779;;;;;:::o;6725:125::-;6630:15;;-1:-1:-1;;;;;6630:15:0;6649:10;6630:29;6622:71;;;;-1:-1:-1;;;6622:71:0;;;;;;;:::i;:::-;6812:15:::1;:30:::0;;-1:-1:-1;;;;;;6812:30:0::1;-1:-1:-1::0;;;;;6812:30:0;;;::::1;::::0;;;::::1;::::0;;6725:125::o;6456:40::-;;;;;;;;;;;;;;;:::o;6862:126::-;6630:15;;-1:-1:-1;;;;;6630:15:0;6649:10;6630:29;6622:71;;;;-1:-1:-1;;;6622:71:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;6955:16:0;;;::::1;;::::0;;;:8:::1;:16;::::0;;;;:25;;-1:-1:-1;;6955:25:0::1;::::0;::::1;;::::0;;;::::1;::::0;;6862:126::o;8472:1405::-;8802:15;;8720:12;;-1:-1:-1;;;;;8790:27:0;:5;;8720:12;8790:8;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;8790:27:0;;:85;;;;-1:-1:-1;8861:14:0;;;;-1:-1:-1;;;;;8834:41:0;:5;;-1:-1:-1;;8840:16:0;;8834:23;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;8834:41:0;;8790:85;:119;;;;-1:-1:-1;8908:1:0;8892:17;;;8790:119;8768:152;;;;;;-1:-1:-1;8997:11:0;;;;9032:1;9019:397;9035:16;;;9019:397;;;9082:322;9100:281;;;;;;;;9142:5;;9152:1;9148;:5;9142:12;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9100:281:0;;;;;9185:7;9100:281;;;;9273:5;;9279:1;9273:8;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9100:281:0;;;;;9312:1;9100:281;;;9383:13;9401:1;9397;:5;9383:20;;;;;;;;;;;;;;9082:17;:322::i;:::-;9072:332;-1:-1:-1;9053:3:0;;9019:397;;;;9505:5;:15;;;9494:7;:26;;9486:63;;;;-1:-1:-1;;;9486:63:0;;;;;;;:::i;:::-;9609:42;9614:5;:14;;;9630:11;9643:7;9609:4;:42::i;:::-;9822:10;-1:-1:-1;;;;;9677:192:0;9770:5;:14;;;-1:-1:-1;;;;;9677:192:0;9705:5;:15;;;-1:-1:-1;;;;;9677:192:0;;9736:5;:11;;;9800:7;9847:11;9677:192;;;;;;;;:::i;:::-;;;;;;;;8472:1405;;;;;;;:::o;12508:273::-;12681:12;12712:61;12733:5;12740;;12747:13;12762:10;12712:20;:61::i;:::-;12705:68;12508:273;-1:-1:-1;;;;;12508:273:0:o;12237:213::-;12366:12;12397:45;12409:5;12416:13;12431:10;12397:11;:45::i;:::-;12390:52;;12237:213;;;;;:::o;9951:2239::-;10096:4;;;10183:121;10203:13;:20;;;:27;10199:1;:31;10183:121;;;10266:13;:20;;;10287:1;10266:23;;;;;;;;;;;;;;10251:38;;;;10232:3;;;;;;;10183:121;;;;10380:6;10376:1754;10396:29;;:36;10392:40;;10376:1754;;;10453:24;10480:13;:29;;;10510:1;10480:32;;;;;;;;;;;;;;10453:59;;10541:14;10598:11;10572:13;:20;;;10593:1;10572:23;;;;;;;;;;;;;;10558:5;:11;;;:37;:51;;;;;;;-1:-1:-1;;;;;;10641:31:0;;10638:1481;;10769:14;10785:10;10797:21;10833:13;:26;;;10860:1;10833:29;;;;;;;;;;;;;;10822:65;;;;;;;;;;;;:::i;:::-;10768:119;;;;;;10925:12;10939:17;10968:6;-1:-1:-1;;;;;10960:20:0;10987:5;10994:8;10960:43;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10924:79;;;;11044:7;11036:43;;;;-1:-1:-1;;;11036:43:0;;;;;;;:::i;:::-;10638:1481;;;;;;;;-1:-1:-1;;;;;11183:27:0;;;;;;:8;:27;;;;;;;;11175:62;;;;-1:-1:-1;;;11175:62:0;;;;;;;:::i;:::-;11257:12;11271:17;11300:8;-1:-1:-1;;;;;11292:30:0;11485:22;;;11576:320;;;;;;;;11634:5;:15;;;-1:-1:-1;;;;;11576:320:0;;;;;11696:9;11576:320;;;;11752:5;:14;;;-1:-1:-1;;;;;11576:320:0;;;;;11813:1;11576:320;;;11927:13;:26;;;11954:1;11927:29;;;;;;;;;;;;;;11535:448;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;11535:448:0;;;;;;;;;;11345:661;;;11535:448;11345:661;;:::i;:::-;;;;-1:-1:-1;;11345:661:0;;;;;;;;;;11292:733;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11256:769;;;;12066:7;12058:45;;;;-1:-1:-1;;;12058:45:0;;;;;;;:::i;:::-;10638:1481;;;-1:-1:-1;;10434:3:0;;10376:1754;;;;12157:25;12167:5;:14;;;12157:9;:25::i;:::-;12150:32;9951:2239;-1:-1:-1;;;;9951:2239:0:o;1326:448::-;1416:12;1422:5;1416;:12::i;:::-;1413:354;;;1470:22;;-1:-1:-1;;;;;1470:14:0;;;:22;;;;;1485:6;;1470:22;;;;1485:6;1470:14;:22;;;;;;;1444:106;;;;-1:-1:-1;;;1444:106:0;;;;;;;:::i;:::-;1413:354;;;1581:40;;-1:-1:-1;;;1581:40:0;;-1:-1:-1;;;;;1581:21:0;;;;;:40;;1603:9;;1614:6;;1581:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1662:29;:27;:29::i;:::-;1636:119;;;;-1:-1:-1;;;1636:119:0;;;;;;;:::i;:::-;1326:448;;;:::o;1032:224::-;1086:12;1113;1119:5;1113;:12::i;:::-;1110:139;;;-1:-1:-1;1148:21:0;1141:28;;1110:139;1207:30;;-1:-1:-1;;;1207:30:0;;-1:-1:-1;;;;;1207:15:0;;;;;:30;;1231:4;;1207:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1200:37;;1110:139;1032:224;;;:::o;3270:257::-;3322:4;-1:-1:-1;;;;;3355:28:0;;;;:73;;-1:-1:-1;;;;;;3400:28:0;;850:42;3400:28;3355:73;3338:182;;;-1:-1:-1;3461:4:0;3454:11;;3338:182;-1:-1:-1;3503:5:0;3496:12;;2619:643;2681:4;;2760:16;2859:160;;;;3038:2;3033:179;;;;2753:459;;2859:160;3003:1;2992:12;;2859:160;;3033:179;3157:2;3154:1;3151;3136:24;3195:1;3189:8;3178:19;;2753:459;-1:-1:-1;3242:12:0;;;-1:-1:-1;2619:643:0;:::o;468:705:-1:-;;594:3;587:4;579:6;575:17;571:27;561:2;;-1:-1;;602:12;561:2;649:6;636:20;671:89;686:73;752:6;686:73;:::i;:::-;671:89;:::i;:::-;788:21;;;662:98;-1:-1;832:4;845:14;;;;820:17;;;940:1;925:242;950:6;947:1;944:13;925:242;;;1033:3;1020:17;824:6;1008:30;4201:3;4182:17;1008:30;4182:17;4178:27;4168:2;;940:1;;4209:12;4168:2;832:4;1008:30;;4243:20;4278:64;4293:48;4334:6;4293:48;:::i;4278:64::-;4362:6;4355:5;4348:21;4386:17;4466:3;4386:17;4457:6;1008:30;4448:16;;4445:25;4442:2;;;940:1;;4473:12;4442:2;27375:6;4386:17;1008:30;4386:17;832:4;4424:5;4420:16;27352:30;-1:-1;940:1;27413:16;;;;;27406:27;;;;1045:59;;-1:-1;1118:14;;;;1146;;;;972:1;965:9;925:242;;;929:14;;;;;554:619;;;;:::o;2025:366::-;;;2169:3;2162:4;2154:6;2150:17;2146:27;2136:2;;-1:-1;;2177:12;2136:2;-1:-1;2207:20;;2247:18;2236:30;;2233:2;;;-1:-1;;2269:12;2233:2;2313:4;2305:6;2301:17;2289:29;;2364:3;2313:4;;2348:6;2344:17;2305:6;2330:32;;2327:41;2324:2;;;2381:1;;2371:12;2324:2;2129:262;;;;;:::o;2447:780::-;;2598:3;2591:4;2583:6;2579:17;2575:27;2565:2;;-1:-1;;2606:12;2565:2;2653:6;2640:20;2675:114;2690:98;2781:6;2690:98;:::i;2675:114::-;2817:21;;;2666:123;-1:-1;2861:4;2874:14;;;;2849:17;;;2969:1;2954:267;2979:6;2976:1;2973:13;2954:267;;;3086:71;3153:3;2861:4;3062:3;3049:17;2853:6;3037:30;;3086:71;:::i;:::-;3074:84;;3172:14;;;;3200;;;;3001:1;2994:9;2954:267;;3253:707;;3370:3;3363:4;3355:6;3351:17;3347:27;3337:2;;-1:-1;;3378:12;3337:2;3425:6;3412:20;3447:80;3462:64;3519:6;3462:64;:::i;3447:80::-;3555:21;;;3438:89;-1:-1;3599:4;3612:14;;;;3587:17;;;3701;;;3692:27;;;;3689:36;-1:-1;3686:2;;;3738:1;;3728:12;3686:2;3763:1;3748:206;3773:6;3770:1;3767:13;3748:206;;;7313:20;;3841:50;;3905:14;;;;3933;;;;3795:1;3788:9;3748:206;;4999:176;5089:20;;5114:56;5089:20;5114:56;:::i;5391:1006::-;;5514:4;5502:9;5497:3;5493:19;5489:30;5486:2;;;-1:-1;;5522:12;5486:2;5550:20;5514:4;5550:20;:::i;:::-;5541:29;;5644:17;5631:31;5682:18;;5674:6;5671:30;5668:2;;;5659:1;;5704:12;5668:2;5833:6;5822:9;5818:22;;;1356:3;1349:4;1341:6;1337:17;1333:27;1323:2;;-1:-1;;1364:12;1323:2;1411:6;1398:20;1433:103;1448:87;1528:6;1448:87;:::i;1433:103::-;1542:16;1578:6;1571:5;1564:21;1608:4;;1625:3;1621:14;1614:21;;1608:4;1600:6;1596:17;1730:3;1608:4;;1714:6;1710:17;1600:6;1701:27;;1698:36;1695:2;;;-1:-1;;1737:12;1695:2;-1:-1;1763:10;;1757:229;1782:6;1779:1;1776:13;1757:229;;;1862:60;1918:3;1906:10;1862:60;:::i;:::-;1850:73;;1804:1;1797:9;;;;;1937:14;;;;1965;;1757:229;;;1761:14;5749:97;5731:16;5724:123;1608:4;5933:9;5929:18;5916:32;5902:46;;5682:18;5960:6;5957:30;5954:2;;;-1:-1;;5990:12;5954:2;6035:83;6114:3;6105:6;6094:9;6090:22;6035:83;:::i;:::-;6017:16;;;6010:109;-1:-1;;;6210:2;6195:18;;6182:32;;-1:-1;6223:30;;;6220:2;;;-1:-1;;6256:12;6220:2;;6301:74;6371:3;6362:6;6351:9;6347:22;6301:74;:::i;:::-;6210:2;6287:5;6283:16;6276:100;;5480:917;;;;:::o;6440:799::-;;6555:4;6543:9;6538:3;6534:19;6530:30;6527:2;;;-1:-1;;6563:12;6527:2;6591:20;6555:4;6591:20;:::i;:::-;6582:29;;5276:6;5263:20;5288:47;5329:5;5288:47;:::i;:::-;6673:89;;6824:2;6878:22;;;7313:20;6839:16;;;6832:75;6972:2;7040:22;;5263:20;5288:47;5263:20;5288:47;:::i;:::-;7005:63;6972:2;6991:5;6987:16;6980:89;;7135:2;7193:9;7189:22;7313:20;7135:2;7154:5;7150:16;7143:75;6521:718;;;;:::o;7524:241::-;;7628:2;7616:9;7607:7;7603:23;7599:32;7596:2;;;-1:-1;;7634:12;7596:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;7686:63;7590:175;-1:-1;;;7590:175::o;7772:648::-;;;;7938:2;7926:9;7917:7;7913:23;7909:32;7906:2;;;-1:-1;;7944:12;7906:2;387:6;381:13;399:41;434:5;399:41;:::i;:::-;8115:2;8165:22;;7461:13;8255:2;8240:18;;8234:25;7996:82;;-1:-1;7461:13;-1:-1;8279:18;8268:30;;8265:2;;;-1:-1;;8301:12;8265:2;8372:22;;4654:4;4642:17;;4638:27;-1:-1;4628:2;;-1:-1;;4669:12;4628:2;4709:6;4703:13;4731:64;4746:48;4787:6;4746:48;:::i;4731:64::-;4815:6;4808:5;4801:21;4919:3;8115:2;4910:6;4843;4901:16;;4898:25;4895:2;;;-1:-1;;4926:12;4895:2;4946:39;4978:6;8115:2;4877:5;4873:16;8115:2;4843:6;4839:17;4946:39;:::i;:::-;8321:83;;;;;;7900:520;;;;;:::o;8427:360::-;;;8545:2;8533:9;8524:7;8520:23;8516:32;8513:2;;;-1:-1;;8551:12;8513:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;8603:63;-1:-1;8703:2;8739:22;;4032:20;26012:13;;26005:21;28229:32;;28219:2;;-1:-1;;28265:12;28219:2;8711:60;;;;8507:280;;;;;:::o;9070:934::-;;;;;9342:3;9330:9;9321:7;9317:23;9313:33;9310:2;;;-1:-1;;9349:12;9310:2;9411:79;9482:7;9458:22;9411:79;:::i;:::-;9401:89;;9555:3;9544:9;9540:19;9527:33;9580:18;;9572:6;9569:30;9566:2;;;-1:-1;;9602:12;9566:2;9640:94;9726:7;9717:6;9706:9;9702:22;9640:94;:::i;:::-;9622:112;;-1:-1;9622:112;-1:-1;9799:3;9784:19;;9771:33;;-1:-1;9813:30;;;9810:2;;;-1:-1;;9846:12;9810:2;;9876:112;9980:7;9971:6;9960:9;9956:22;9876:112;:::i;:::-;9866:122;;;9304:700;;;;;;;:::o;10011:1076::-;;;;;;10308:3;10296:9;10287:7;10283:23;10279:33;10276:2;;;-1:-1;;10315:12;10276:2;10377:79;10448:7;10424:22;10377:79;:::i;:::-;10367:89;;10521:3;10510:9;10506:19;10493:33;10546:18;;10538:6;10535:30;10532:2;;;-1:-1;;10568:12;10532:2;10606:94;10692:7;10683:6;10672:9;10668:22;10606:94;:::i;:::-;10588:112;;-1:-1;10588:112;-1:-1;10765:3;10750:19;;10737:33;;-1:-1;10779:30;;;10776:2;;;-1:-1;;10812:12;10776:2;;10842:112;10946:7;10937:6;10926:9;10922:22;10842:112;:::i;:::-;10832:122;;;10991:3;11043:9;11039:22;217:20;242:41;277:5;242:41;:::i;:::-;11000:71;;;;10270:817;;;;;;;;:::o;11094:574::-;;;11275:3;11263:9;11254:7;11250:23;11246:33;11243:2;;;-1:-1;;11282:12;11243:2;11344:79;11415:7;11391:22;11344:79;:::i;:::-;11334:89;;11488:3;11477:9;11473:19;11460:33;11513:18;11505:6;11502:30;11499:2;;;-1:-1;;11535:12;11499:2;11565:87;11644:7;11635:6;11624:9;11620:22;11565:87;:::i;:::-;11555:97;;;11237:431;;;;;:::o;11675:716::-;;;;11881:3;11869:9;11860:7;11856:23;11852:33;11849:2;;;-1:-1;;11888:12;11849:2;11950:79;12021:7;11997:22;11950:79;:::i;:::-;11940:89;;12094:3;12083:9;12079:19;12066:33;12119:18;12111:6;12108:30;12105:2;;;-1:-1;;12141:12;12105:2;12171:87;12250:7;12241:6;12230:9;12226:22;12171:87;:::i;:::-;12161:97;;;12295:3;12347:9;12343:22;217:20;242:41;277:5;242:41;:::i;:::-;12304:71;;;;11843:548;;;;;:::o;12398:263::-;;12513:2;12501:9;12492:7;12488:23;12484:32;12481:2;;;-1:-1;;12519:12;12481:2;-1:-1;7461:13;;12475:186;-1:-1;12475:186::o;17538:405::-;-1:-1;;;;;;26099:78;;13135:56;;25205:12;;17538:405;;13824:52;25205:12;17805:1;17796:11;;13857:4;13846:16;;13824:52;:::i;:::-;13888:16;;;;17805:1;13888:16;;17698:245;-1:-1;;;17698:245::o;17950:271::-;;13713:5;25205:12;13824:52;13869:6;13864:3;13857:4;13850:5;13846:16;13824:52;:::i;:::-;13888:16;;;;;18084:137;-1:-1;;18084:137::o;18228:222::-;-1:-1;;;;;26484:54;;;;12888:37;;18355:2;18340:18;;18326:124::o;18457:349::-;-1:-1;;;;;26484:54;;;;12747:58;;18792:2;18777:18;;17369:37;18620:2;18605:18;;18591:215::o;18813:210::-;26012:13;;26005:21;13002:34;;18934:2;18919:18;;18905:118::o;19030:416::-;19230:2;19244:47;;;14292:2;19215:18;;;25349:19;-1:-1;;;25389:14;;;14308:45;14372:12;;;19201:245::o;19453:416::-;19653:2;19667:47;;;14623:2;19638:18;;;25349:19;14659:25;25389:14;;;14639:46;14704:12;;;19624:245::o;19876:416::-;20076:2;20090:47;;;14955:2;20061:18;;;25349:19;14991:31;25389:14;;;14971:52;15042:12;;;20047:245::o;20299:416::-;20499:2;20513:47;;;15293:2;20484:18;;;25349:19;15329:27;25389:14;;;15309:48;15376:12;;;20470:245::o;20722:416::-;20922:2;20936:47;;;15627:2;20907:18;;;25349:19;-1:-1;;;25389:14;;;15643:45;15707:12;;;20893:245::o;21145:416::-;21345:2;21359:47;;;15958:2;21330:18;;;25349:19;15994:26;25389:14;;;15974:47;16040:12;;;21316:245::o;21568:416::-;21768:2;21782:47;;;16291:2;21753:18;;;25349:19;16327:30;25389:14;;;16307:51;16377:12;;;21739:245::o;21991:523::-;;2247:18;;26495:42;;;;16694:16;16688:23;26484:54;13998:3;13991:64;16874:4;16867:5;16863:16;16857:23;16874:4;16938:3;16934:14;17369:37;26495:42;17032:4;17025:5;17021:16;17015:23;26484:54;17032:4;17110:3;17106:14;13991:64;;17205:4;17198:5;17194:16;17188:23;17205:4;17269:3;17265:14;17369:37;22216:3;22387;22376:9;22372:19;22365:49;13345:5;25205:12;25361:6;22216:3;22205:9;22201:19;25349;13438:52;13483:6;25389:14;22205:9;25389:14;16874:4;13464:5;13460:16;13438:52;:::i;:::-;27888:7;27872:14;-1:-1;;27868:28;13502:39;;;;25389:14;13502:39;;22187:327;-1:-1;;;22187:327::o;22521:222::-;17369:37;;;22648:2;22633:18;;22619:124::o;22750:460::-;17369:37;;;23105:2;23090:18;;17369:37;;;;-1:-1;;;;;26484:54;23196:2;23181:18;;12747:58;22941:2;22926:18;;22912:298::o;23217:256::-;23279:2;23273:9;23305:17;;;23380:18;23365:34;;23401:22;;;23362:62;23359:2;;;23437:1;;23427:12;23359:2;23279;23446:22;23257:216;;-1:-1;23257:216::o;23480:313::-;;23648:18;23640:6;23637:30;23634:2;;;-1:-1;;23670:12;23634:2;-1:-1;23715:4;23703:17;;;23768:15;;23571:222::o;24790:321::-;;24933:18;24925:6;24922:30;24919:2;;;-1:-1;;24955:12;24919:2;-1:-1;27888:7;25009:17;-1:-1;;25005:33;25096:4;25086:15;;24856:255::o;27448:268::-;27513:1;27520:101;27534:6;27531:1;27528:13;27520:101;;;27601:11;;;27595:18;27582:11;;;27575:39;27556:2;27549:10;27520:101;;;27636:6;27633:1;27630:13;27627:2;;;27513:1;27692:6;27687:3;27683:16;27676:27;27627:2;;27497:219;;;:::o;27909:117::-;-1:-1;;;;;26484:54;;27968:35;;27958:2;;28017:1;;28007:12;27958:2;27952:74;:::o

ipfs://429da80915842f70f9c40f3718a68c9e0ff922540c8baebba8351ac8681c19f0