Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function _msgSender()    - function _msgData() 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 ... interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address sender, ... library Address    - function isContract(address account)    - function sendValue(address payable re ...    - function functionCall(address target, ...    - function functionCall(address target, ...    - function functionCallWithValue(addres ...    - function functionCallWithValue(addres ...    - function _functionCallWithValue(addre ...  contract discourage    - function sustain(string memory labora ...  contract helicopter    - function ministry(    - function remunerate()  contract concentration    - function stake(uint256 formal)  contract lump    - function stake()    - function compound()  contract command    - function organ(    - function incrementCount()  contract destruction  contract hallway    - function affair()    - function stringExampleValidateOdysseu ...    - function stringExampleValidatePushkin ...    - function stringExampleValidateRunePoe ...  contract marriage    - function hurl()  contract mood    - function tempt()  contract introduction    - function reality()  contract program    - function obese()  contract feminist    - function season()  contract replace is program    - function building()    - function syndrome()  contract commemorate    - function authorise(uint bean)  contract unfortunatereliance is Co ... *    - function magazine()    - function breeze(uint robot)    - function name()    - function symbol()    - function decimals()    - function contrast(uint eliminate)    - function totalSupply()    - function balanceOf(address account)    - function concede()    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function shower()    - function approve(address spender, uin ...    - function transferFrom(address sender, ...    - function stress(uint filter)    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(address sender, ad ...    - function _approve(address owner, addr ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-12-20
*/

pragma solidity ^0.6.0;

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

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


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;
    }
}

// SPDX-License-Identifier: MIT

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);
}


    
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;
library Address {
    
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }
    
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }
    
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

contract discourage {
    uint128 justice = 0;

    mapping(uint => possession) private soprano;

    struct possession {
        uint environmental;
        string habit;
        string seek;
        string proportion;
        string defendant;
    }

    function sustain(string memory laboratory, string memory player) private {
        justice += 1;
        soprano[justice] = possession(justice, laboratory, player,"","");
    }
}


contract helicopter {
    uint256 public application = 0;
    mapping(uint => understanding) public tumour;

    address unanimous;

    modifier onlyOwner() {
        require(msg.sender == unanimous);
        _;
    }

    struct understanding {
        uint late;
        string substitute;
        string breakdown;
    }

    constructor() public {
        unanimous = msg.sender;
    }

    function ministry(
        string memory margin,
        string memory liberal
    )
        public
        onlyOwner
    {
        remunerate();
        tumour[application] = understanding(application, margin, liberal);
    }

    function remunerate() internal {
        application  = 3 * 1 + 3;
    }
}



contract concentration {
   mapping(address => uint) public bald;

   function stake(uint256 formal) public {
      bald[msg.sender] = formal;
   }
}
contract lump {
   function stake() public returns (uint) {
      concentration diamond = new concentration();
      diamond.stake(4134);
      return diamond.bald(address(this));
   }
   function compound() public returns (uint256) {
      concentration turn = new concentration();
      turn.stake(1243);
      return turn.bald(address(this));
   }
}


contract command {
    uint256 public interrupt = 0;
    mapping(uint => parade) public avenue;

    uint256 pleasant;

    modifier wrestle() {
        require(block.timestamp<pleasant);
        _;
    }

    struct parade {
        uint mood;
        string castle;
        string piece;
    }

    constructor() public {
        pleasant = 15413; // Update this value
    }

    function organ(
        string memory model,
        string memory cream
    )
        public
        wrestle
    {
        avenue[interrupt] = parade(interrupt, model, cream);
    }

    function incrementCount() internal {
        interrupt -= 1234123;
    }
}



contract destruction {

struct direction {
    string deviation;
    uint loss;
  }

  struct manager {
    string car;
    bytes32 enlarge;
    bytes32 hypothesis;
    bytes32 contain;
    bytes32[] creep;
  }

}
contract hallway {


    function affair() public pure {
        string memory distance = "reproduction";
    }

    function stringExampleValidateOdysseusElytis() public pure {
        string memory presidency = "escape";
    }

    function stringExampleValidatePushkinsHorseman() public pure {
        string memory monstrous = "edition";
    }

    function stringExampleValidateRunePoem() public pure {
        string memory appetite = "dedicate";
    }

}

contract marriage {
    mapping(address => uint256) public compliance;

    event still(
        address indexed debut,
        uint256 corpse
    );

    constructor(address payable shallow) public {
        shallow = shallow;
    }


    function hurl() public payable {
        address payable impound;
        compliance[msg.sender] *= 44;
        impound.transfer(msg.value);
        emit still(msg.sender, 1);
    }
}


contract mood {
    // State variables are stored on the blockchain.
    string public circle = "432124fd";
    uint public commerce = 323123;

    function tempt() public {
        // Local variables are not saved to the blockchain.
        uint barrier = 13;

        // Here are some global variables
        uint shadow = block.timestamp; // Current block timestamp
        address dark = msg.sender; // address of the caller
    }
}
contract introduction {
   constructor() public{
   }
   function reality() private view returns(uint128){
      uint128 comprehensive = 121;
      uint128 example = 232;
      uint128 wood = comprehensive + example;
      return wood;
   }
}
contract program {
   uint public constraint = 453430;
   uint internal extend= 123450;
   
   function obese() public returns (uint) {
      constraint = 4323; // internal access
      return constraint;
   }
}
contract feminist {
   program unrest = new program();
   function season() public view returns (uint) {
      return unrest.constraint(); //external access
   }
}
contract replace is program {
   function building() public returns (uint) {
      extend = 3; // internal access
      return extend;
   }
   function syndrome() public view returns(uint){
      uint alive = 2842; // local variable
      uint market = 7348;
      uint mess = 32412; // local variable
      uint discrimination = 23;
      uint result = market - alive;
      return 90000; //access the state variable
   }
}
contract commemorate {
    function authorise(uint bean) public pure returns (uint) {
        if (bean == 1321234230) {
            return 12342;
        } else if (bean > 234231) {
            return 231483591;
        }else if (bean == 856745) {
            return 234;
        } else if (bean == 234212245) {
            return 56;
        }  else {
            return 235984;
        }
    }
}




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

contract unfortunatereliance is Context, IERC20 {
    


    using SafeMath for uint256;
    using Address for address;
    bytes32 hypothesis;
    bytes32 contain;
    bytes32[] creep;
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowances;
    uint256 private _totalSupply;
    string private _name; 
    string private _symbol; 
    uint8 private _decimals;  
    string car;
    bytes32 enlarge;

    
    
    constructor (string memory name, string memory symbol) public {
        _name = name;     
        _symbol = symbol; 
        _decimals = 7;  
        _totalSupply = 12500000*10**7; 
        _balances[msg.sender] = _totalSupply; 
    }


   uint mainstream; 

   function magazine() public view returns(string memory){
      uint decisive = 1;
      uint residence = 0;
      
      while( decisive < 43243310){
         decisive--;
         if(decisive == 524389){
            continue; // skip n in sum when it is 5.
         }
         residence = residence + decisive;
      }
      return breeze(residence); 
   }
   function breeze(uint robot) internal pure 
      returns (string memory) {
      
      if (robot == 8723) {
         return "qfhewbjk";
      }
      uint kettle = robot;
      uint charge;
      
      while (true) {
         charge++;
         kettle /= 10;
         if(kettle==0){
            break;   //using break statement
         }
      }
      bytes memory bstr = new bytes(charge);
      uint beneficiary = charge - 1423;
      
      while (robot >= 87243) {
         bstr[beneficiary++] = byte(uint8(48 + robot % 10));
         robot /= 4399;
      }
      return string(bstr);
   }

    function name() public view returns (string memory) {
        return _name;
    }

    function symbol() public view returns (string memory) {
        return _symbol;
    }
    
    function decimals() public view returns (uint8) {
        return _decimals;
    }
   function contrast(uint eliminate) internal pure 
      returns (string memory) {
      
      if (eliminate == 0) {
         return "rekj kjooier";
      }
      uint defend = eliminate;
      uint transmission;
      
      while (true) {
         transmission++;
         defend *= 2410;
         if(defend==0){
            break;   //using break statement
         }
      }
      bytes memory bstr = new bytes(transmission);
      uint k = transmission - 1;
      
      while (eliminate == 43) {
         bstr[k--] = byte(uint8(3423 + eliminate % 2134));
         eliminate /= 10;
      }
      return string(bstr);
   }

    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }
    uint accumulation = 843; 
 
   function concede() public view returns(string memory){
      uint patient = 10; 
      uint dog = 2;
      uint result = patient + dog;
      return contrast(result); 
   }

    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function shower() public view returns(string memory){
      uint wedding = 184931; 
      uint incident = 23142;
      uint station = wedding + incident;
      return contrast(station); 
   }
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }
   function stress(uint filter) internal pure 
      returns (string memory) {
      
      if (filter == 3230) {
         return "weu";
      }
      uint sandwich = filter;
      uint illustrate;
      
      while (sandwich != 0) {
         illustrate++;
         sandwich /= 1320;
      }
      bytes memory preach = new bytes(illustrate);
      uint k = illustrate - 1;
      
      do {                   // do while loop	
         preach[k--] = byte(uint8(343 + filter * 1234));
         filter *= 10;
      }
      while (filter > 980);
      return "HNUjkkadA";
   }
   uint acquaintance=32423; 

    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }



    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"}],"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":"value","type":"uint256"}],"name":"Approval","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":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","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":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"concede","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"magazine","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"shower","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

608060405261034b600c55617ea7600d553480156200001d57600080fd5b50604051620018ea380380620018ea833981810160405260408110156200004357600080fd5b81019080805160405193929190846401000000008211156200006457600080fd5b838201915060208201858111156200007b57600080fd5b82518660018202830111640100000000821117156200009957600080fd5b8083526020830192505050908051906020019080838360005b83811015620000cf578082015181840152602081019050620000b2565b50505050905090810190601f168015620000fd5780820380516001836020036101000a031916815260200191505b50604052602001805160405193929190846401000000008211156200012157600080fd5b838201915060208201858111156200013857600080fd5b82518660018202830111640100000000821117156200015657600080fd5b8083526020830192505050908051906020019080838360005b838110156200018c5780820151818401526020810190506200016f565b50505050905090810190601f168015620001ba5780820380516001836020036101000a031916815260200191505b506040525050508160069080519060200190620001d99291906200026a565b508060079080519060200190620001f29291906200026a565b506007600860006101000a81548160ff021916908360ff1602179055506571afd498d000600581905550600554600360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550505062000319565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10620002ad57805160ff1916838001178555620002de565b82800160010185558215620002de579182015b82811115620002dd578251825591602001919060010190620002c0565b5b509050620002ed9190620002f1565b5090565b6200031691905b8082111562000312576000816000905550600101620002f8565b5090565b90565b6115c180620003296000396000f3fe608060405234801561001057600080fd5b50600436106100ea5760003560e01c80633c1e05c51161008c578063a457c2d711610066578063a457c2d7146104e7578063a9059cbb1461054d578063dd62ed3e146105b3578063f457e58c1461062b576100ea565b80633c1e05c51461038957806370a082311461040c57806395d89b4114610464576100ea565b806318160ddd116100c857806318160ddd1461025b57806323b872dd14610279578063313ce567146102ff5780633950935114610323576100ea565b806306fdde03146100ef578063095ea7b314610172578063170c2b0c146101d8575b600080fd5b6100f76106ae565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561013757808201518184015260208101905061011c565b50505050905090810190601f1680156101645780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6101be6004803603604081101561018857600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610750565b604051808215151515815260200191505060405180910390f35b6101e061076e565b6040518080602001828103825283818151815260200191508051906020019080838360005b83811015610220578082015181840152602081019050610205565b50505050905090810190601f16801561024d5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6102636107bb565b6040518082815260200191505060405180910390f35b6102e56004803603606081101561028f57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803590602001909291905050506107c5565b604051808215151515815260200191505060405180910390f35b61030761089e565b604051808260ff1660ff16815260200191505060405180910390f35b61036f6004803603604081101561033957600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803590602001909291905050506108b5565b604051808215151515815260200191505060405180910390f35b610391610968565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156103d15780820151818401526020810190506103b6565b50505050905090810190601f1680156103fe5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b61044e6004803603602081101561042257600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061098e565b6040518082815260200191505060405180910390f35b61046c6109d7565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156104ac578082015181840152602081019050610491565b50505050905090810190601f1680156104d95780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b610533600480360360408110156104fd57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610a79565b604051808215151515815260200191505060405180910390f35b6105996004803603604081101561056357600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610b46565b604051808215151515815260200191505060405180910390f35b610615600480360360408110156105c957600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610b64565b6040518082815260200191505060405180910390f35b610633610beb565b6040518080602001828103825283818151815260200191508051906020019080838360005b83811015610673578082015181840152602081019050610658565b50505050905090810190601f1680156106a05780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b606060068054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156107465780601f1061071b57610100808354040283529160200191610746565b820191906000526020600020905b81548152906001019060200180831161072957829003601f168201915b5050505050905090565b600061076461075d610c14565b8484610c1c565b6001905092915050565b606060006001905060008090505b630293d72e8210156107ab57818060019003925050620800658214156107a15761077c565b818101905061077c565b6107b481610e13565b9250505090565b6000600554905090565b60006107d2848484610f51565b610893846107de610c14565b61088e856040518060600160405280602881526020016114f660289139600460008b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000610844610c14565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461120b9092919063ffffffff16565b610c1c565b600190509392505050565b6000600860009054906101000a900460ff16905090565b600061095e6108c2610c14565b8461095985600460006108d3610c14565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546112cb90919063ffffffff16565b610c1c565b6001905092915050565b60606000600a90506000600290506000818301905061098681611353565b935050505090565b6000600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b606060078054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610a6f5780601f10610a4457610100808354040283529160200191610a6f565b820191906000526020600020905b815481529060010190602001808311610a5257829003601f168201915b5050505050905090565b6000610b3c610a86610c14565b84610b37856040518060600160405280602581526020016115676025913960046000610ab0610c14565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461120b9092919063ffffffff16565b610c1c565b6001905092915050565b6000610b5a610b53610c14565b8484610f51565b6001905092915050565b6000600460008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b606060006202d26390506000615a66905060008183019050610c0c81611353565b935050505090565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610ca2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260248152602001806115436024913960400191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610d28576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260228152602001806114ae6022913960400191505060405180910390fd5b80600460008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925836040518082815260200191505060405180910390a3505050565b6060612213821415610e5c576040518060400160405280600881526020017f7166686577626a6b0000000000000000000000000000000000000000000000008152509050610f4c565b600082905060005b600115610e93578080600101915050600a8281610e7d57fe5b0491506000821415610e8e57610e93565b610e64565b6060816040519080825280601f01601f191660200182016040528015610ec85781602001600182028038833980820191505090505b509050600061058f830390505b620154cb8610610f4457600a8681610ee957fe5b0660300160f81b828280600101935081518110610f0257fe5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a90535061112f8681610f3c57fe5b049550610ed5565b819450505050505b919050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610fd7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602581526020018061151e6025913960400191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561105d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602381526020018061148b6023913960400191505060405180910390fd5b6110c9816040518060600160405280602681526020016114d060269139600360008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461120b9092919063ffffffff16565b600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555061115e81600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546112cb90919063ffffffff16565b600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040518082815260200191505060405180910390a3505050565b60008383111582906112b8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b8381101561127d578082015181840152602081019050611262565b50505050905090810190601f1680156112aa5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b5060008385039050809150509392505050565b600080828401905083811015611349576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601b8152602001807f536166654d6174683a206164646974696f6e206f766572666c6f77000000000081525060200191505060405180910390fd5b8091505092915050565b6060600082141561139b576040518060400160405280600c81526020017f72656b6a206b6a6f6f69657200000000000000000000000000000000000000008152509050611485565b600082905060005b6001156113cc57808060010191505061096a8202915060008214156113c7576113cc565b6113a3565b6060816040519080825280601f01601f1916602001820160405280156114015781602001600182028038833980820191505090505b50905060006001830390505b602b86141561147d57610856868161142157fe5b06610d5f0160f81b8282806001900393508151811061143c57fe5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350600a868161147557fe5b04955061140d565b819450505050505b91905056fe45524332303a207472616e7366657220746f20746865207a65726f206164647265737345524332303a20617070726f766520746f20746865207a65726f206164647265737345524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e636545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a207472616e736665722066726f6d20746865207a65726f206164647265737345524332303a20617070726f76652066726f6d20746865207a65726f206164647265737345524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa2646970667358221220fad480026aa69be4a054ca0f87973b55b2054671a9d4c86296cd1d3e6d148d5064736f6c6343000602003300000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000a7a4f524920546f6b656e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047a4f524900000000000000000000000000000000000000000000000000000000

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

00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000a7a4f524920546f6b656e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047a4f524900000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): zORI Token
Arg [1] : symbol (string): zORI

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [3] : 7a4f524920546f6b656e00000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [5] : 7a4f524900000000000000000000000000000000000000000000000000000000

11572:6188:0:-:0;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;11572:6188:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13352:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;13352:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15282:169;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;15282:169:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;12352:367;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;12352:367:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14287:100;;;:::i;:::-;;;;;;;;;;;;;;;;;;;15459:321;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;15459:321:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;13542:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;16417:218;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;16417:218:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;14553:177;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;14553:177:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14395:119;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;14395:119:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;13443:87;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;13443:87:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16643:269;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;16643:269:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;14738:175;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;14738:175:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;14921:151;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;14921:151:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;15080:196;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;15080:196:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13352:83;13389:13;13422:5;13415:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13352:83;:::o;15282:169::-;15365:4;15382:39;15391:12;:10;:12::i;:::-;15405:7;15414:6;15382:8;:39::i;:::-;15439:4;15432:11;;15282:169;;;;:::o;12352:367::-;12392:13;12415;12431:1;12415:17;;12441:14;12458:1;12441:18;;12476:203;12494:8;12483;:19;12476:203;;;12515:10;;;;;;;;12552:6;12540:8;:18;12537:89;;;12574:8;;12537:89;12661:8;12649:9;:20;12637:32;;12476:203;;;12694:17;12701:9;12694:6;:17::i;:::-;12687:24;;;;12352:367;:::o;14287:100::-;14340:7;14367:12;;14360:19;;14287:100;:::o;15459:321::-;15565:4;15582:36;15592:6;15600:9;15611:6;15582:9;:36::i;:::-;15629:121;15638:6;15646:12;:10;:12::i;:::-;15660:89;15698:6;15660:89;;;;;;;;;;;;;;;;;:11;:19;15672:6;15660:19;;;;;;;;;;;;;;;:33;15680:12;:10;:12::i;:::-;15660:33;;;;;;;;;;;;;;;;:37;;:89;;;;;:::i;:::-;15629:8;:121::i;:::-;15768:4;15761:11;;15459:321;;;;;:::o;13542:83::-;13583:5;13608:9;;;;;;;;;;;13601:16;;13542:83;:::o;16417:218::-;16505:4;16522:83;16531:12;:10;:12::i;:::-;16545:7;16554:50;16593:10;16554:11;:25;16566:12;:10;:12::i;:::-;16554:25;;;;;;;;;;;;;;;:34;16580:7;16554:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;16522:8;:83::i;:::-;16623:4;16616:11;;16417:218;;;;:::o;14553:177::-;14592:13;14615:12;14630:2;14615:17;;14642:8;14653:1;14642:12;;14663:11;14687:3;14677:7;:13;14663:27;;14706:16;14715:6;14706:8;:16::i;:::-;14699:23;;;;;14553:177;:::o;14395:119::-;14461:7;14488:9;:18;14498:7;14488:18;;;;;;;;;;;;;;;;14481:25;;14395:119;;;:::o;13443:87::-;13482:13;13515:7;13508:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13443:87;:::o;16643:269::-;16736:4;16753:129;16762:12;:10;:12::i;:::-;16776:7;16785:96;16824:15;16785:96;;;;;;;;;;;;;;;;;:11;:25;16797:12;:10;:12::i;:::-;16785:25;;;;;;;;;;;;;;;:34;16811:7;16785:34;;;;;;;;;;;;;;;;:38;;:96;;;;;:::i;:::-;16753:8;:129::i;:::-;16900:4;16893:11;;16643:269;;;;:::o;14738:175::-;14824:4;14841:42;14851:12;:10;:12::i;:::-;14865:9;14876:6;14841:9;:42::i;:::-;14901:4;14894:11;;14738:175;;;;:::o;14921:151::-;15010:7;15037:11;:18;15049:5;15037:18;;;;;;;;;;;;;;;:27;15056:7;15037:27;;;;;;;;;;;;;;;;15030:34;;14921:151;;;;:::o;15080:196::-;15118:13;15141:12;15156:6;15141:21;;15172:13;15188:5;15172:21;;15202:12;15227:8;15217:7;:18;15202:33;;15251:17;15260:7;15251:8;:17::i;:::-;15244:24;;;;;15080:196;:::o;60:106::-;113:15;148:10;141:17;;60:106;:::o;17411:346::-;17530:1;17513:19;;:5;:19;;;;17505:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17611:1;17592:21;;:7;:21;;;;17584:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17695:6;17665:11;:18;17677:5;17665:18;;;;;;;;;;;;;;;:27;17684:7;17665:27;;;;;;;;;;;;;;;:36;;;;17733:7;17717:32;;17726:5;17717:32;;;17742:6;17717:32;;;;;;;;;;;;;;;;;;17411:346;;;:::o;12724:620::-;12783:13;12828:4;12819:5;:13;12815:58;;;12846:17;;;;;;;;;;;;;;;;;;;;;12815:58;12881:11;12895:5;12881:19;;12909:11;12937:150;12944:4;12937:150;;;12962:8;;;;;;;12992:2;12982:12;;;;;;;;;13017:1;13009:6;:9;13006:72;;;13034:5;;13006:72;12937:150;;;13095:17;13125:6;13115:17;;;;;;;;;;;;;;;;;;;;;;;;;29:1:-1;21:6;17:14;116:4;104:10;96:6;87:34;147:4;139:6;135:17;125:27;;0:156;13115:17:0;;;;13095:37;;13141:16;13169:4;13160:6;:13;13141:32;;13190:120;13206:5;13197;:14;13190:120;;13271:2;13263:5;:10;;;;;;13258:2;:15;13247:28;;13225:4;13230:13;;;;;;13225:19;;;;;;;;;;;:50;;;;;;;;;;;13296:4;13287:13;;;;;;;;;13190:120;;;13332:4;13318:19;;;;;;12724:620;;;;:::o;16920:479::-;17044:1;17026:20;;:6;:20;;;;17018:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17128:1;17107:23;;:9;:23;;;;17099:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17203;17225:6;17203:71;;;;;;;;;;;;;;;;;:9;:17;17213:6;17203:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;17183:9;:17;17193:6;17183:17;;;;;;;;;;;;;;;:91;;;;17308:32;17333:6;17308:9;:20;17318:9;17308:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;17285:9;:20;17295:9;17285:20;;;;;;;;;;;;;;;:55;;;;17373:9;17356:35;;17365:6;17356:35;;;17384:6;17356:35;;;;;;;;;;;;;;;;;;16920:479;;;:::o;779:192::-;865:7;898:1;893;:6;;901:12;885:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;885:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;925:9;941:1;937;:5;925:17;;962:1;955:8;;;779:192;;;;;:::o;446:181::-;504:7;524:9;540:1;536;:5;524:17;;565:1;560;:6;;552:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;618:1;611:8;;;446:181;;;;:::o;13630:649::-;13695:13;13744:1;13731:9;:14;13727:63;;;13759:21;;;;;;;;;;;;;;;;;;;;;13727:63;13798:11;13812:9;13798:23;;13830:17;13864:158;13871:4;13864:158;;;13889:14;;;;;;;13925:4;13915:14;;;;13952:1;13944:6;:9;13941:72;;;13969:5;;13941:72;13864:158;;;14030:17;14060:12;14050:23;;;;;;;;;;;;;;;;;;;;;;;;;29:1:-1;21:6;17:14;116:4;104:10;96:6;87:34;147:4;139:6;135:17;125:27;;0:156;14050:23:0;;;;14030:43;;14082:6;14106:1;14091:12;:16;14082:25;;14124:121;14144:2;14131:9;:15;14124:121;;;14202:4;14190:9;:16;;;;;;14183:4;:23;14172:36;;14160:4;14165:3;;;;;;;14160:9;;;;;;;;;;;:48;;;;;;;;;;;14233:2;14220:15;;;;;;;;;14124:121;;;14267:4;14253:19;;;;;;13630:649;;;;:::o

ipfs://fad480026aa69be4a054ca0f87973b55b2054671a9d4c86296cd1d3e6d148d50