Contract 0xd756f821F7e26da2B492299347C10AE03f994D83

/**
 *Submitted for verification at BscScan.com on 2021-04-08
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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




/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}



/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The defaut value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overloaded;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        _approve(sender, _msgSender(), currentAllowance - amount);

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);

        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    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");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        _balances[sender] = senderBalance - amount;
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        _balances[account] = accountBalance - amount;
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

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

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}





/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}






/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
   /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (array[mid] > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && array[low - 1] == element) {
            return low - 1;
        } else {
            return low;
        }
    }
}





/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }
}





/**
 * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and
 * total supply at the time are recorded for later access.
 *
 * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting.
 * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different
 * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be
 * used to create an efficient ERC20 forking mechanism.
 *
 * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a
 * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot
 * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id
 * and the account address.
 *
 * ==== Gas Costs
 *
 * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log
 * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much
 * smaller since identical balances in subsequent snapshots are stored as a single entry.
 *
 * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is
 * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent
 * transfers will have normal cost until the next snapshot, and so on.
 */
abstract contract ERC20Snapshot is ERC20 {
    // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
    // https://github.com/Giveth/minimd/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

    using Arrays for uint256[];
    using Counters for Counters.Counter;

    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
    // Snapshot struct, but that would impede usage of functions that work on an array.
    struct Snapshots {
        uint256[] ids;
        uint256[] values;
    }

    mapping (address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;

    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
    Counters.Counter private _currentSnapshotId;

    /**
     * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created.
     */
    event Snapshot(uint256 id);

    /**
     * @dev Creates a new snapshot and returns its snapshot id.
     *
     * Emits a {Snapshot} event that contains the same id.
     *
     * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
     * set of accounts, for example using {AccessControl}, or it may be open to the public.
     *
     * [WARNING]
     * ====
     * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking,
     * you must consider that it can potentially be used by attackers in two ways.
     *
     * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow
     * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target
     * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs
     * section above.
     *
     * We haven't measured the actual numbers; if this is something you're interested in please reach out to us.
     * ====
     */
    function _snapshot() internal virtual returns (uint256) {
        _currentSnapshotId.increment();

        uint256 currentId = _currentSnapshotId.current();
        emit Snapshot(currentId);
        return currentId;
    }

    /**
     * @dev Retrieves the balance of `account` at the time `snapshotId` was created.
     */
    function balanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);

        return snapshotted ? value : balanceOf(account);
    }

    /**
     * @dev Retrieves the total supply at the time `snapshotId` was created.
     */
    function totalSupplyAt(uint256 snapshotId) public view virtual returns(uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);

        return snapshotted ? value : totalSupply();
    }


    // Update balance and/or total supply snapshots before the values are modified. This is implemented
    // in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations.
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
      super._beforeTokenTransfer(from, to, amount);

      if (from == address(0)) {
        // mint
        _updateAccountSnapshot(to);
        _updateTotalSupplySnapshot();
      } else if (to == address(0)) {
        // burn
        _updateAccountSnapshot(from);
        _updateTotalSupplySnapshot();
      } else {
        // transfer
        _updateAccountSnapshot(from);
        _updateAccountSnapshot(to);
      }
    }

    function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
        private view returns (bool, uint256)
    {
        require(snapshotId > 0, "ERC20Snapshot: id is 0");
        // solhint-disable-next-line max-line-length
        require(snapshotId <= _currentSnapshotId.current(), "ERC20Snapshot: nonexistent id");

        // When a valid snapshot is queried, there are three possibilities:
        //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
        //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
        //  to this id is the current one.
        //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
        //  requested id, and its value is the one to return.
        //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
        //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
        //  larger than the requested one.
        //
        // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
        // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
        // exactly this.

        uint256 index = snapshots.ids.findUpperBound(snapshotId);

        if (index == snapshots.ids.length) {
            return (false, 0);
        } else {
            return (true, snapshots.values[index]);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }

    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
        uint256 currentId = _currentSnapshotId.current();
        if (_lastSnapshotId(snapshots.ids) < currentId) {
            snapshots.ids.push(currentId);
            snapshots.values.push(currentValue);
        }
    }

    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
        if (ids.length == 0) {
            return 0;
        } else {
            return ids[ids.length - 1];
        }
    }
}






contract BSCLAUNCH is ERC20Snapshot{

    address private _devAddress;
    // totalSupply capped at 5.000.000
    uint256 private _cap = 5000000 * 10**18;

    modifier onlyDev() {
        require(msg.sender == _devAddress, "msg.Sender != _devAddress");
        _;
    }

    constructor(
        string memory name,
        string memory symbol,
        address initalHolder,
        uint256 initialSupply
    ) 
    ERC20(name, symbol){
        _devAddress = initalHolder;
        require(ERC20.totalSupply() + initialSupply <= cap(), "ERC20Capped: cap exceeded");
        _mint(initalHolder, initialSupply);
    }

    function mint(address account, uint256 amount) external onlyDev {
        require(ERC20.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
        _mint(account, amount);
    }

    function burn(address account, uint256 amount) external onlyDev {
        _burn(account, amount);
    }

    function snapshot() external onlyDev returns (uint256) {
        return _snapshot();
    }

    function cap() public view virtual returns (uint256) {
        return _cap;
    }
}

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"address","name":"initalHolder","type":"address"},{"internalType":"uint256","name":"initialSupply","type":"uint256"}],"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":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","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":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"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":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"snapshot","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","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":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","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"}]

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000078c25c2c4c415348fc44916c0ec2acf371a82516000000000000000000000000000000000000000000000fe1c215e8f838e0000000000000000000000000000000000000000000000000000000000000000000094253434c41554e4348000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064c41554e43480000000000000000000000000000000000000000000000000000

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 00000000000000000000000078c25c2c4c415348fc44916c0ec2acf371a82516
Arg [3] : 000000000000000000000000000000000000000000000fe1c215e8f838e00000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [5] : 4253434c41554e43480000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [7] : 4c41554e43480000000000000000000000000000000000000000000000000000

26450:1143:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6162:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8329:169;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;7282:108::-;;;:::i;:::-;;;;;;;:::i;8980:422::-;;;;;;:::i;:::-;;:::i;7124:93::-;;;:::i;:::-;;;;;;;:::i;27507:83::-;;;:::i;9811:215::-;;;;;;:::i;:::-;;:::i;27095:191::-;;;;;;:::i;:::-;;:::i;:::-;;22546:266;;;;;;:::i;:::-;;:::i;7453:127::-;;;;;;:::i;:::-;;:::i;6381:104::-;;;:::i;27407:92::-;;;:::i;22916:233::-;;;;;;:::i;:::-;;:::i;27294:105::-;;;;;;:::i;:::-;;:::i;10529:377::-;;;;;;:::i;:::-;;:::i;7793:175::-;;;;;;:::i;:::-;;:::i;8031:151::-;;;;;;:::i;:::-;;:::i;6162:100::-;6216:13;6249:5;6242:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6162:100;:::o;8329:169::-;8412:4;8429:39;8438:12;:10;:12::i;:::-;8452:7;8461:6;8429:8;:39::i;:::-;-1:-1:-1;8486:4:0;8329:169;;;;;:::o;7282:108::-;7370:12;;7282:108;:::o;8980:422::-;9086:4;9103:36;9113:6;9121:9;9132:6;9103:9;:36::i;:::-;-1:-1:-1;;;;;9179:19:0;;9152:24;9179:19;;;:11;:19;;;;;9152:24;9199:12;:10;:12::i;:::-;-1:-1:-1;;;;;9179:33:0;-1:-1:-1;;;;;9179:33:0;;;;;;;;;;;;;9152:60;;9251:6;9231:16;:26;;9223:79;;;;-1:-1:-1;;;9223:79:0;;;;;;;:::i;:::-;;;;;;;;;9313:57;9322:6;9330:12;:10;:12::i;:::-;9344:25;9363:6;9344:16;:25;:::i;:::-;9313:8;:57::i;:::-;-1:-1:-1;9390:4:0;;8980:422;-1:-1:-1;;;;8980:422:0:o;7124:93::-;7207:2;7124:93;:::o;27507:83::-;27578:4;;27507:83;:::o;9811:215::-;9899:4;9916:80;9925:12;:10;:12::i;:::-;9939:7;9985:10;9948:11;:25;9960:12;:10;:12::i;:::-;-1:-1:-1;;;;;9948:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;9948:25:0;;;:34;;;;;;;;;;:47;;;;:::i;27095:191::-;26668:11;;-1:-1:-1;;;;;26668:11:0;26654:10;:25;26646:63;;;;-1:-1:-1;;;26646:63:0;;;;;;;:::i;:::-;27210:5:::1;:3;:5::i;:::-;27200:6;27178:19;:17;:19::i;:::-;:28;;;;:::i;:::-;:37;;27170:75;;;;-1:-1:-1::0;;;27170:75:0::1;;;;;;;:::i;:::-;27256:22;27262:7;27271:6;27256:5;:22::i;:::-;27095:191:::0;;:::o;22546:266::-;-1:-1:-1;;;;;22710:33:0;;22633:7;22710:33;;;:24;:33;;;;;22633:7;;;;22689:55;;22698:10;;22689:8;:55::i;:::-;22653:91;;;;22764:11;:40;;22786:18;22796:7;22786:9;:18::i;:::-;22764:40;;;22778:5;22764:40;22757:47;22546:266;-1:-1:-1;;;;;22546:266:0:o;7453:127::-;-1:-1:-1;;;;;7554:18:0;;7527:7;7554:18;;;;;;;;;;;7453:127;;;;:::o;6381:104::-;6437:13;6470:7;6463:14;;;;;:::i;27407:92::-;26668:11;;27453:7;;-1:-1:-1;;;;;26668:11:0;26654:10;:25;26646:63;;;;-1:-1:-1;;;26646:63:0;;;;;;;:::i;:::-;27480:11:::1;:9;:11::i;:::-;27473:18;;27407:92:::0;:::o;22916:233::-;22987:7;23008:16;23026:13;23043:43;23052:10;23064:21;23043:8;:43::i;:::-;23007:79;;;;23106:11;:35;;23128:13;:11;:13::i;:::-;23106:35;;;23120:5;23106:35;23099:42;22916:233;-1:-1:-1;;;;22916:233:0:o;27294:105::-;26668:11;;-1:-1:-1;;;;;26668:11:0;26654:10;:25;26646:63;;;;-1:-1:-1;;;26646:63:0;;;;;;;:::i;:::-;27369:22:::1;27375:7;27384:6;27369:5;:22::i;10529:377::-:0;10622:4;10639:24;10666:11;:25;10678:12;:10;:12::i;:::-;-1:-1:-1;;;;;10666:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;10666:25:0;;;:34;;;;;;;;;;;-1:-1:-1;10719:35:0;;;;10711:85;;;;-1:-1:-1;;;10711:85:0;;;;;;;:::i;:::-;10807:67;10816:12;:10;:12::i;:::-;10830:7;10839:34;10858:15;10839:16;:34;:::i;10807:67::-;-1:-1:-1;10894:4:0;;10529:377;-1:-1:-1;;;10529:377:0:o;7793:175::-;7879:4;7896:42;7906:12;:10;:12::i;:::-;7920:9;7931:6;7896:9;:42::i;8031:151::-;-1:-1:-1;;;;;8147:18:0;;;8120:7;8147:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8031:151::o;14834:92::-;;;;:::o;17896:114::-;17988:14;;17896:114::o;601:98::-;681:10;601:98;:::o;13885:346::-;-1:-1:-1;;;;;13987:19:0;;13979:68;;;;-1:-1:-1;;;13979:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;14066:21:0;;14058:68;;;;-1:-1:-1;;;14058:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;14139:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;14191:32;;;;;14169:6;;14191:32;:::i;:::-;;;;;;;;13885:346;;;:::o;11396:604::-;-1:-1:-1;;;;;11502:20:0;;11494:70;;;;-1:-1:-1;;;11494:70:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;11583:23:0;;11575:71;;;;-1:-1:-1;;;11575:71:0;;;;;;;:::i;:::-;11659:47;11680:6;11688:9;11699:6;11659:20;:47::i;:::-;-1:-1:-1;;;;;11743:17:0;;11719:21;11743:17;;;;;;;;;;;11779:23;;;;11771:74;;;;-1:-1:-1;;;11771:74:0;;;;;;;:::i;:::-;11876:22;11892:6;11876:13;:22;:::i;:::-;-1:-1:-1;;;;;11856:17:0;;;:9;:17;;;;;;;;;;;:42;;;;11909:20;;;;;;;;:30;;11933:6;;11856:9;11909:30;;11933:6;;11909:30;:::i;:::-;;;;;;;;11974:9;-1:-1:-1;;;;;11957:35:0;11966:6;-1:-1:-1;;;;;11957:35:0;;11985:6;11957:35;;;;;;:::i;:::-;;;;;;;;11396:604;;;;:::o;12282:338::-;-1:-1:-1;;;;;12366:21:0;;12358:65;;;;-1:-1:-1;;;12358:65:0;;;;;;;:::i;:::-;12436:49;12465:1;12469:7;12478:6;12436:20;:49::i;:::-;12514:6;12498:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;12531:18:0;;:9;:18;;;;;;;;;;:28;;12553:6;;12531:9;:28;;12553:6;;12531:28;:::i;:::-;;;;-1:-1:-1;;12575:37:0;;-1:-1:-1;;;;;12575:37:0;;;12592:1;;12575:37;;;;12605:6;;12575:37;:::i;:::-;;;;;;;;12282:338;;:::o;23918:1692::-;24016:4;24022:7;24068:1;24055:10;:14;24047:49;;;;-1:-1:-1;;;24047:49:0;;;;;;;:::i;:::-;24183:28;:18;:26;:28::i;:::-;24169:10;:42;;24161:84;;;;-1:-1:-1;;;24161:84:0;;;;;;;:::i;:::-;25384:13;25400:40;:9;25429:10;25400:28;:40::i;:::-;25466:20;;25384:56;;-1:-1:-1;25457:29:0;;25453:150;;;25511:5;25518:1;25503:17;;;;;;;25453:150;25561:4;25567:9;:16;;25584:5;25567:23;;;;;;-1:-1:-1;;;25567:23:0;;;;;;;;;;;;;;;;;25553:38;;;;;23918:1692;;;;;;:::o;22206:228::-;22253:7;22273:30;:18;:28;:30::i;:::-;22316:17;22336:28;:18;:26;:28::i;:::-;22316:48;;22380:19;22389:9;22380:19;;;;;;:::i;:::-;;;;;;;;22417:9;-1:-1:-1;22206:228:0;:::o;12953:494::-;-1:-1:-1;;;;;13037:21:0;;13029:67;;;;-1:-1:-1;;;13029:67:0;;;;;;;:::i;:::-;13109:49;13130:7;13147:1;13151:6;13109:20;:49::i;:::-;-1:-1:-1;;;;;13196:18:0;;13171:22;13196:18;;;;;;;;;;;13233:24;;;;13225:71;;;;-1:-1:-1;;;13225:71:0;;;;;;;:::i;:::-;13328:23;13345:6;13328:14;:23;:::i;:::-;-1:-1:-1;;;;;13307:18:0;;:9;:18;;;;;;;;;;:44;;;;13362:12;:22;;13378:6;;13307:9;13362:22;;13378:6;;13362:22;:::i;:::-;;;;-1:-1:-1;;13402:37:0;;13428:1;;-1:-1:-1;;;;;13402:37:0;;;;;;;13432:6;;13402:37;:::i;23368:542::-;23475:44;23502:4;23508:2;23512:6;23475:26;:44::i;:::-;-1:-1:-1;;;;;23534:18:0;;23530:373;;23582:26;23605:2;23582:22;:26::i;:::-;23619:28;:26;:28::i;:::-;23530:373;;;-1:-1:-1;;;;;23667:16:0;;23663:240;;23713:28;23736:4;23713:22;:28::i;23663:240::-;23828:28;23851:4;23828:22;:28::i;:::-;23867:26;23890:2;23867:22;:26::i;16232:918::-;16345:12;;16321:7;;16341:58;;-1:-1:-1;16386:1:0;16379:8;;16341:58;16452:12;;16411:11;;16477:424;16490:4;16484:3;:10;16477:424;;;16511:11;16525:23;16538:3;16543:4;16525:12;:23::i;:::-;16511:37;;16782:7;16769:5;16775:3;16769:10;;;;;;-1:-1:-1;;;16769:10:0;;;;;;;;;;;;;;;;;:20;16765:125;;;16817:3;16810:10;;16765:125;;;16867:7;:3;16873:1;16867:7;:::i;:::-;16861:13;;16765:125;16477:424;;;;17027:1;17021:3;:7;:36;;;;-1:-1:-1;17050:7:0;17032:5;17038:7;17044:1;17038:3;:7;:::i;:::-;17032:14;;;;;;-1:-1:-1;;;17032:14:0;;;;;;;;;;;;;;;;;:25;17021:36;17017:126;;;17081:7;17087:1;17081:3;:7;:::i;:::-;17074:14;;;;;;17017:126;-1:-1:-1;17128:3:0;-1:-1:-1;17121:10:0;;18018:127;18107:19;;18125:1;18107:19;;;18018:127::o;25618:146::-;-1:-1:-1;;;;;25702:33:0;;;;;;:24;:33;;;;;25686:70;;25737:18;25727:7;25737:9;:18::i;:::-;25686:15;:70::i;:::-;25618:146;:::o;25772:118::-;25829:53;25845:21;25868:13;:11;:13::i;25829:53::-;25772:118::o;15513:193::-;15575:7;15696:1;15687:5;15696:1;15687;:5;:::i;:::-;15679;15683:1;15679;:5;:::i;:::-;:13;;;;:::i;:::-;15678:19;;;;:::i;:::-;15668:5;15672:1;15668;:5;:::i;:::-;15658;15662:1;15658;:5;:::i;:::-;15657:17;;;;:::i;:::-;:41;;;;:::i;:::-;15650:48;15513:193;-1:-1:-1;;;15513:193:0:o;25898:315::-;25993:17;26013:28;:18;:26;:28::i;:::-;25993:48;-1:-1:-1;25993:48:0;26056:30;26072:9;26056:15;:30::i;:::-;:42;26052:154;;;26115:29;;;;;;;;-1:-1:-1;26115:29:0;;;;;;;;;;;;;;26159:16;;;:35;;;;;;;;;;;;;;;25898:315::o;26221:212::-;26315:10;;26291:7;;26311:115;;-1:-1:-1;26354:1:0;26347:8;;26311:115;26399:10;;26395:3;;26399:14;;26412:1;;26399:14;:::i;:::-;26395:19;;;;;;-1:-1:-1;;;26395:19:0;;;;;;;;;;;;;;;;;26388:26;;;;14:175:1;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;397:274::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;;625:40;661:2;650:9;646:18;625:40;:::i;:::-;615:50;;484:187;;;;;:::o;676:342::-;;;;822:2;810:9;801:7;797:23;793:32;790:2;;;843:6;835;828:22;790:2;871:31;892:9;871:31;:::i;:::-;861:41;;921:40;957:2;946:9;942:18;921:40;:::i;:::-;911:50;;1008:2;997:9;993:18;980:32;970:42;;780:238;;;;;:::o;1023:266::-;;;1152:2;1140:9;1131:7;1127:23;1123:32;1120:2;;;1173:6;1165;1158:22;1120:2;1201:31;1222:9;1201:31;:::i;:::-;1191:41;1279:2;1264:18;;;;1251:32;;-1:-1:-1;;;1110:179:1:o;1294:190::-;;1406:2;1394:9;1385:7;1381:23;1377:32;1374:2;;;1427:6;1419;1412:22;1374:2;-1:-1:-1;1455:23:1;;1364:120;-1:-1:-1;1364:120:1:o;1489:187::-;1654:14;;1647:22;1629:41;;1617:2;1602:18;;1584:92::o;1681:603::-;;1822:2;1851;1840:9;1833:21;1883:6;1877:13;1926:6;1921:2;1910:9;1906:18;1899:34;1951:4;1964:140;1978:6;1975:1;1972:13;1964:140;;;2073:14;;;2069:23;;2063:30;2039:17;;;2058:2;2035:26;2028:66;1993:10;;1964:140;;;2122:6;2119:1;2116:13;2113:2;;;2192:4;2187:2;2178:6;2167:9;2163:22;2159:31;2152:45;2113:2;-1:-1:-1;2268:2:1;2247:15;-1:-1:-1;;2243:29:1;2228:45;;;;2275:2;2224:54;;1802:482;-1:-1:-1;;;1802:482:1:o;2289:353::-;2491:2;2473:21;;;2530:2;2510:18;;;2503:30;2569:31;2564:2;2549:18;;2542:59;2633:2;2618:18;;2463:179::o;2647:399::-;2849:2;2831:21;;;2888:2;2868:18;;;2861:30;2927:34;2922:2;2907:18;;2900:62;-1:-1:-1;;;2993:2:1;2978:18;;2971:33;3036:3;3021:19;;2821:225::o;3051:349::-;3253:2;3235:21;;;3292:2;3272:18;;;3265:30;3331:27;3326:2;3311:18;;3304:55;3391:2;3376:18;;3225:175::o;3405:398::-;3607:2;3589:21;;;3646:2;3626:18;;;3619:30;3685:34;3680:2;3665:18;;3658:62;-1:-1:-1;;;3751:2:1;3736:18;;3729:32;3793:3;3778:19;;3579:224::o;3808:398::-;4010:2;3992:21;;;4049:2;4029:18;;;4022:30;4088:34;4083:2;4068:18;;4061:62;-1:-1:-1;;;4154:2:1;4139:18;;4132:32;4196:3;4181:19;;3982:224::o;4211:402::-;4413:2;4395:21;;;4452:2;4432:18;;;4425:30;4491:34;4486:2;4471:18;;4464:62;-1:-1:-1;;;4557:2:1;4542:18;;4535:36;4603:3;4588:19;;4385:228::o;4618:404::-;4820:2;4802:21;;;4859:2;4839:18;;;4832:30;4898:34;4893:2;4878:18;;4871:62;-1:-1:-1;;;4964:2:1;4949:18;;4942:38;5012:3;4997:19;;4792:230::o;5027:397::-;5229:2;5211:21;;;5268:2;5248:18;;;5241:30;5307:34;5302:2;5287:18;;5280:62;-1:-1:-1;;;5373:2:1;5358:18;;5351:31;5414:3;5399:19;;5201:223::o;5429:401::-;5631:2;5613:21;;;5670:2;5650:18;;;5643:30;5709:34;5704:2;5689:18;;5682:62;-1:-1:-1;;;5775:2:1;5760:18;;5753:35;5820:3;5805:19;;5603:227::o;5835:349::-;6037:2;6019:21;;;6076:2;6056:18;;;6049:30;6115:27;6110:2;6095:18;;6088:55;6175:2;6160:18;;6009:175::o;6189:400::-;6391:2;6373:21;;;6430:2;6410:18;;;6403:30;6469:34;6464:2;6449:18;;6442:62;-1:-1:-1;;;6535:2:1;6520:18;;6513:34;6579:3;6564:19;;6363:226::o;6594:346::-;6796:2;6778:21;;;6835:2;6815:18;;;6808:30;-1:-1:-1;;;6869:2:1;6854:18;;6847:52;6931:2;6916:18;;6768:172::o;6945:401::-;7147:2;7129:21;;;7186:2;7166:18;;;7159:30;7225:34;7220:2;7205:18;;7198:62;-1:-1:-1;;;7291:2:1;7276:18;;7269:35;7336:3;7321:19;;7119:227::o;7351:355::-;7553:2;7535:21;;;7592:2;7572:18;;;7565:30;7631:33;7626:2;7611:18;;7604:61;7697:2;7682:18;;7525:181::o;7711:177::-;7857:25;;;7845:2;7830:18;;7812:76::o;7893:184::-;8065:4;8053:17;;;;8035:36;;8023:2;8008:18;;7990:87::o;8082:128::-;;8153:1;8149:6;8146:1;8143:13;8140:2;;;8159:18;;:::i;:::-;-1:-1:-1;8195:9:1;;8130:80::o;8215:120::-;;8281:1;8271:2;;8286:18;;:::i;:::-;-1:-1:-1;8320:9:1;;8261:74::o;8340:125::-;;8408:1;8405;8402:8;8399:2;;;8413:18;;:::i;:::-;-1:-1:-1;8450:9:1;;8389:76::o;8470:380::-;8555:1;8545:12;;8602:1;8592:12;;;8613:2;;8667:4;8659:6;8655:17;8645:27;;8613:2;8720;8712:6;8709:14;8689:18;8686:38;8683:2;;;8766:10;8761:3;8757:20;8754:1;8747:31;8801:4;8798:1;8791:15;8829:4;8826:1;8819:15;8683:2;;8525:325;;;:::o;8855:112::-;;8913:1;8903:2;;8918:18;;:::i;:::-;-1:-1:-1;8952:9:1;;8893:74::o;8972:127::-;9033:10;9028:3;9024:20;9021:1;9014:31;9064:4;9061:1;9054:15;9088:4;9085:1;9078:15;9104:127;9165:10;9160:3;9156:20;9153:1;9146:31;9196:4;9193:1;9186:15;9220:4;9217:1;9210:15

ipfs://c5b9ac974fb750bd34838f301f11b3abf912901bf6a54aed39abe721be98dc4f