Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function _msgData() interface IERC20 library SafeMath library Address    - function _functionCallWithValue(addre ...  contract ERC20 is Context, IERC20  contract Ownable is Context  contract Chip is ERC20("C ... *    - function airdrop(address[] memory add ...    - function _delegate(address delegator, ...    - function _moveDelegates(address srcRe ...    - function _writeCheckpoint(    - function safe32(uint n, string memory ...    - function getChainId()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-03-04
*/

// SPDX-License-Identifier: MIT																									
																									
pragma solidity ^0.6.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 GSN 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 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;																									
}																									
}																									
																									
																									
pragma solidity ^0.6.0;																									
																									
/**																									
* @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);																									
}																									
																									
pragma solidity ^0.6.0;																									
																									
/**																									
* @dev Wrappers over Solidity's arithmetic operations with added overflow																									
* checks.																									
*																									
* Arithmetic operations in Solidity wrap on overflow. This can easily result																									
* in bugs, because programmers usually assume that an overflow raises an																									
* error, which is the standard behavior in high level programming languages.																									
* `SafeMath` restores this intuition by reverting the transaction when an																									
* operation overflows.																									
*																									
* Using this library instead of the unchecked operations eliminates an entire																									
* class of bugs, so it's recommended to use it always.																									
*/																									
library SafeMath {																									
/**																									
* @dev Returns the addition of two unsigned integers, reverting on																									
* overflow.																									
*																									
* Counterpart to Solidity's `+` operator.																									
*																									
* Requirements:																									
*																									
* - Addition cannot overflow.																									
*/																									
function add(uint256 a, uint256 b) internal pure returns (uint256) {																									
uint256 c = a + b;																									
require(c >= a, "SafeMath: addition overflow");																									
																									
return c;																									
}																									
																									
/**																									
* @dev Returns the subtraction of two unsigned integers, reverting on																									
* overflow (when the result is negative).																									
*																									
* Counterpart to Solidity's `-` operator.																									
*																									
* Requirements:																									
*																									
* - Subtraction cannot overflow.																									
*/																									
function sub(uint256 a, uint256 b) internal pure returns (uint256) {																									
return sub(a, b, "SafeMath: subtraction overflow");																									
}																									
																									
/**																									
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on																									
* overflow (when the result is negative).																									
*																									
* Counterpart to Solidity's `-` operator.																									
*																									
* Requirements:																									
*																									
* - Subtraction cannot overflow.																									
*/																									
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {																									
require(b <= a, errorMessage);																									
uint256 c = a - b;																									
																									
return c;																									
}																									
																									
/**																									
* @dev Returns the multiplication of two unsigned integers, reverting on																									
* overflow.																									
*																									
* Counterpart to Solidity's `*` operator.																									
*																									
* Requirements:																									
*																									
* - Multiplication cannot overflow.																									
*/																									
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;																									
}																									
																									
/**																									
* @dev Returns the integer division of two unsigned integers. Reverts on																									
* division by zero. The result is rounded towards zero.																									
*																									
* Counterpart to Solidity's `/` operator. Note: this function uses a																									
* `revert` opcode (which leaves remaining gas untouched) while Solidity																									
* uses an invalid opcode to revert (consuming all remaining gas).																									
*																									
* Requirements:																									
*																									
* - The divisor cannot be zero.																									
*/																									
function div(uint256 a, uint256 b) internal pure returns (uint256) {																									
return div(a, b, "SafeMath: division by zero");																									
}																									
																									
/**																									
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on																									
* division by zero. The result is rounded towards zero.																									
*																									
* Counterpart to Solidity's `/` operator. Note: this function uses a																									
* `revert` opcode (which leaves remaining gas untouched) while Solidity																									
* uses an invalid opcode to revert (consuming all remaining gas).																									
*																									
* Requirements:																									
*																									
* - The divisor cannot be 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;																									
}																									
																									
/**																									
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),																									
* Reverts when dividing by zero.																									
*																									
* Counterpart to Solidity's `%` operator. This function uses a `revert`																									
* opcode (which leaves remaining gas untouched) while Solidity uses an																									
* invalid opcode to revert (consuming all remaining gas).																									
*																									
* Requirements:																									
*																									
* - The divisor cannot be zero.																									
*/																									
function mod(uint256 a, uint256 b) internal pure returns (uint256) {																									
return mod(a, b, "SafeMath: modulo by zero");																									
}																									
																									
/**																									
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),																									
* Reverts with custom message when dividing by zero.																									
*																									
* Counterpart to Solidity's `%` operator. This function uses a `revert`																									
* opcode (which leaves remaining gas untouched) while Solidity uses an																									
* invalid opcode to revert (consuming all remaining gas).																									
*																									
* Requirements:																									
*																									
* - The divisor cannot be zero.																									
*/																									
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {																									
require(b != 0, errorMessage);																									
return a % b;																									
}																									
}																									
																									
pragma solidity ^0.6.2;																									
																									
/**																									
* @dev Collection of functions related to the address type																									
*/																									
library Address {																									
/**																									
* @dev Returns true if `account` is a contract.																									
*																									
* [IMPORTANT]																									
* ====																									
* It is unsafe to assume that an address for which this function returns																									
* false is an externally-owned account (EOA) and not a contract.																									
*																									
* Among others, `isContract` will return false for the following																									
* types of addresses:																									
*																									
*  - an externally-owned account																									
*  - a contract in construction																									
*  - an address where a contract will be created																									
*  - an address where a contract lived, but was destroyed																									
* ====																									
*/																									
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);																									
}																									
																									
/**																									
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to																									
* `recipient`, forwarding all available gas and reverting on errors.																									
*																									
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost																									
* of certain opcodes, possibly making contracts go over the 2300 gas limit																									
* imposed by `transfer`, making them unable to receive funds via																									
* `transfer`. {sendValue} removes this limitation.																									
*																									
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].																									
*																									
* IMPORTANT: because control is transferred to `recipient`, care must be																									
* taken to not create reentrancy vulnerabilities. Consider using																									
* {ReentrancyGuard} or the																									
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].																									
*/																									
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");																									
}																									
																									
/**																									
* @dev Performs a Solidity function call using a low level `call`. A																									
* plain`call` is an unsafe replacement for a function call: use this																									
* function instead.																									
*																									
* If `target` reverts with a revert reason, it is bubbled up by this																									
* function (like regular Solidity function calls).																									
*																									
* Returns the raw returned data. To convert to the expected return value,																									
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].																									
*																									
* Requirements:																									
*																									
* - `target` must be a contract.																									
* - calling `target` with `data` must not revert.																									
*																									
* _Available since v3.1._																									
*/																									
function functionCall(address target, bytes memory data) internal returns (bytes memory) {																									
return functionCall(target, data, "Address: low-level call failed");																									
}																									
																									
/**																									
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with																									
* `errorMessage` as a fallback revert reason when `target` reverts.																									
*																									
* _Available since v3.1._																									
*/																									
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {																									
return _functionCallWithValue(target, data, 0, errorMessage);																									
}																									
																									
/**																									
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],																									
* but also transferring `value` wei to `target`.																									
*																									
* Requirements:																									
*																									
* - the calling contract must have an ETH balance of at least `value`.																									
* - the called Solidity function must be `payable`.																									
*																									
* _Available since v3.1._																									
*/																									
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");																									
}																									
																									
/**																									
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but																									
* with `errorMessage` as a fallback revert reason when `target` reverts.																									
*																									
* _Available since v3.1._																									
*/																									
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);																									
}																									
}																									
}																									
}																									
																									
pragma solidity ^0.6.0;																									
																									
																									
/**																									
* @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 {																									
using SafeMath for uint256;																									
using Address for address;																									
																									
mapping (address => uint256) private _balances;																									
																									
mapping (address => mapping (address => uint256)) private _allowances;																									
																									
uint256 private _totalSupply;																									
																									
string private _name;																									
string private _symbol;																									
uint8 private _decimals;																									
																									
/**																									
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with																									
* a default value of 18.																									
*																									
* To select a different value for {decimals}, use {_setupDecimals}.																									
*																									
* All three of these values are immutable: they can only be set once during																									
* construction.																									
*/																									
constructor (string memory name, string memory symbol) public {																									
_name = name;																									
_symbol = symbol;																									
_decimals = 18;																									
}																									
																									
/**																									
* @dev Returns the name of the token.																									
*/																									
function name() public view returns (string memory) {																									
return _name;																									
}																									
																									
/**																									
* @dev Returns the symbol of the token, usually a shorter version of the																									
* name.																									
*/																									
function symbol() public view 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 {_setupDecimals} is																									
* called.																									
*																									
* 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 returns (uint8) {																									
return _decimals;																									
}																									
																									
/**																									
* @dev See {IERC20-totalSupply}.																									
*/																									
function totalSupply() public view override returns (uint256) {																									
return _totalSupply;																									
}																									
																									
/**																									
* @dev See {IERC20-balanceOf}.																									
*/																									
function balanceOf(address account) public view 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);																									
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));																									
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].add(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) {																									
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));																									
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);																									
																									
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");																									
_balances[recipient] = _balances[recipient].add(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 = _totalSupply.add(amount);																									
_balances[account] = _balances[account].add(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);																									
																									
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");																									
_totalSupply = _totalSupply.sub(amount);																									
emit Transfer(account, address(0), amount);																									
}																									
																									
/**																									
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.																									
*																									
* This is 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 Sets {decimals} to a value other than the default one of 18.																									
*																									
* WARNING: This function should only be called from the constructor. Most																									
* applications that interact with token contracts will not expect																									
* {decimals} to ever change, and may work incorrectly if it does.																									
*/																									
function _setupDecimals(uint8 decimals_) internal {																									
_decimals = decimals_;																									
}																									
																									
/**																									
* @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 { }																									
}																									
																									
																									
pragma solidity ^0.6.0;																									
																									
/**																									
* @dev Contract module which provides a basic access control mechanism, where																									
* there is an account (an owner) that can be granted exclusive access to																									
* specific functions.																									
*																									
* By default, the owner account will be the one that deploys the contract. This																									
* can later be changed with {transferOwnership}.																									
*																									
* This module is used through inheritance. It will make available the modifier																									
* `onlyOwner`, which can be applied to your functions to restrict their use to																									
* the owner.																									
*/																									
contract Ownable is Context {																									
address private _owner;																									
																									
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);																									
																									
/**																									
* @dev Initializes the contract setting the deployer as the initial owner.																									
*/																									
constructor () internal {																									
address msgSender = _msgSender();																									
_owner = msgSender;																									
emit OwnershipTransferred(address(0), msgSender);																									
}																									
																									
/**																									
* @dev Returns the address of the current owner.																									
*/																									
function owner() public view returns (address) {																									
return _owner;																									
}																									
																									
/**																									
* @dev Throws if called by any account other than the owner.																									
*/																									
modifier onlyOwner() {																									
require(_owner == _msgSender(), "Ownable: caller is not the owner");																									
_;																									
}																									
																									
/**																									
* @dev Leaves the contract without owner. It will not be possible to call																									
* `onlyOwner` functions anymore. Can only be called by the current owner.																									
*																									
* NOTE: Renouncing ownership will leave the contract without an owner,																									
* thereby removing any functionality that is only available to the owner.																									
*/																									
function renounceOwnership() public virtual onlyOwner {																									
emit OwnershipTransferred(_owner, address(0));																									
_owner = address(0);																									
}																									
																									
/**																									
* @dev Transfers ownership of the contract to a new account (`newOwner`).																									
* Can only be called by the current owner.																									
*/																									
function transferOwnership(address newOwner) public virtual onlyOwner {																									
require(newOwner != address(0), "Ownable: new owner is the zero address");																									
emit OwnershipTransferred(_owner, newOwner);																									
_owner = newOwner;																									
}																									
}																									
																									
pragma solidity 0.6.12;																									
																									
// Chip with Governance.																									
contract Chip is ERC20("Chip", "CHIP"), Ownable {																									
																									
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).																									
function mint(address _to, uint256 _amount) public onlyOwner {																									
_mint(_to, _amount);																									
_moveDelegates(address(0), _delegates[_to], _amount);																									
}																									
																									
function airdrop(address[] memory addresses, uint256[] memory amounts) public onlyOwner returns (bool) {																									
require(addresses.length > 0 && addresses.length == amounts.length);																									
																									
uint256 totalAmount = 0;																									
																									
for(uint j = 0; j < addresses.length; j++){																									
require(amounts[j] > 0 && addresses[j] != address(0));																									
totalAmount = totalAmount.add(amounts[j]);																									
}																									
																									
require(balanceOf(msg.sender) >= totalAmount);																									
																									
for (uint j = 0; j < addresses.length; j++) {																									
transfer(addresses[j], amounts[j]);																									
}																									
																									
return true;																									
}																									
																									
// Copied and modified from YAM code:																									
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol																									
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol																									
// Which is copied and modified from COMPOUND:																									
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol																									
																									
// @notice A record of each accounts delegate																									
mapping (address => address) internal _delegates;																									
																									
/// @notice A checkpoint for marking number of votes from a given block																									
struct Checkpoint {																									
uint32 fromBlock;																									
uint256 votes;																									
}																									
																									
/// @notice A record of votes checkpoints for each account, by index																									
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;																									
																									
/// @notice The number of checkpoints for each account																									
mapping (address => uint32) public numCheckpoints;																									
																									
/// @notice The EIP-712 typehash for the contract's domain																									
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");																									
																									
/// @notice The EIP-712 typehash for the delegation struct used by the contract																									
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");																									
																									
/// @notice A record of states for signing / validating signatures																									
mapping (address => uint) public nonces;																									
																									
/// @notice An event thats emitted when an account changes its delegate																									
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);																									
																									
/// @notice An event thats emitted when a delegate account's vote balance changes																									
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);																									
																									
/**																									
* @notice Delegate votes from `msg.sender` to `delegatee`																									
* @param delegator The address to get delegatee for																									
*/																									
function delegates(address delegator)																									
external																									
view																									
returns (address)																									
{																									
return _delegates[delegator];																									
}																									
																									
/**																									
* @notice Delegate votes from `msg.sender` to `delegatee`																									
* @param delegatee The address to delegate votes to																									
*/																									
function delegate(address delegatee) external {																									
return _delegate(msg.sender, delegatee);																									
}																									
																									
/**																									
* @notice Delegates votes from signatory to `delegatee`																									
* @param delegatee The address to delegate votes to																									
* @param nonce The contract state required to match the signature																									
* @param expiry The time at which to expire the signature																									
* @param v The recovery byte of the signature																									
* @param r Half of the ECDSA signature pair																									
* @param s Half of the ECDSA signature pair																									
*/																									
function delegateBySig(																									
address delegatee,																									
uint nonce,																									
uint expiry,																									
uint8 v,																									
bytes32 r,																									
bytes32 s																									
)																									
external																									
{																									
bytes32 domainSeparator = keccak256(																									
abi.encode(																									
DOMAIN_TYPEHASH,																									
keccak256(bytes(name())),																									
getChainId(),																									
address(this)																									
)																									
);																									
																									
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,delegatee,nonce,expiry));																									
																									
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",domainSeparator,structHash));																									
																									
address signatory = ecrecover(digest, v, r, s);																									
require(signatory != address(0), "CHIP::delegateBySig: invalid signature");																									
require(nonce == nonces[signatory]++, "CHIP::delegateBySig: invalid nonce");																									
require(now <= expiry, "CHIP::delegateBySig: signature expired");																									
return _delegate(signatory, delegatee);																									
}																									
																									
/**																									
* @notice Gets the current votes balance for `account`																									
* @param account The address to get votes balance																									
* @return The number of current votes for `account`																									
*/																									
function getCurrentVotes(address account)																									
external																									
view																									
returns (uint256)																									
{																									
uint32 nCheckpoints = numCheckpoints[account];																									
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;																									
}																									
																									
/**																									
* @notice Determine the prior number of votes for an account as of a block number																									
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.																									
* @param account The address of the account to check																									
* @param blockNumber The block number to get the vote balance at																									
* @return The number of votes the account had as of the given block																									
*/																									
function getPriorVotes(address account, uint blockNumber)																									
external																									
view																									
returns (uint256)																									
{																									
require(blockNumber < block.number, "CHIP::getPriorVotes: not yet determined");																									
																									
uint32 nCheckpoints = numCheckpoints[account];																									
if (nCheckpoints == 0) {																									
return 0;																									
}																									
																									
// First check most recent balance																									
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {																									
return checkpoints[account][nCheckpoints - 1].votes;																									
}																									
																									
// Next check implicit zero balance																									
if (checkpoints[account][0].fromBlock > blockNumber) {																									
return 0;																									
}																									
																									
uint32 lower = 0;																									
uint32 upper = nCheckpoints - 1;																									
while (upper > lower) {																									
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow																									
Checkpoint memory cp = checkpoints[account][center];																									
if (cp.fromBlock == blockNumber) {																									
return cp.votes;																									
} else if (cp.fromBlock < blockNumber) {																									
lower = center;																									
} else {																									
upper = center - 1;																									
}																									
}																									
return checkpoints[account][lower].votes;																									
}																									
																									
function _delegate(address delegator, address delegatee)																									
internal																									
{																									
address currentDelegate = _delegates[delegator];																									
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CHIPs (not scaled);																									
_delegates[delegator] = delegatee;																									
																									
emit DelegateChanged(delegator, currentDelegate, delegatee);																									
																									
_moveDelegates(currentDelegate, delegatee, delegatorBalance);																									
}																									
																									
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {																									
if (srcRep != dstRep && amount > 0) {																									
if (srcRep != address(0)) {																									
// decrease old representative																									
uint32 srcRepNum = numCheckpoints[srcRep];																									
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;																									
uint256 srcRepNew = srcRepOld.sub(amount);																									
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);																									
}																									
																									
if (dstRep != address(0)) {																									
// increase new representative																									
uint32 dstRepNum = numCheckpoints[dstRep];																									
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;																									
uint256 dstRepNew = dstRepOld.add(amount);																									
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);																									
}																									
}																									
}																									
																									
function _writeCheckpoint(																									
address delegatee,																									
uint32 nCheckpoints,																									
uint256 oldVotes,																									
uint256 newVotes																									
)																									
internal																									
{																									
uint32 blockNumber = safe32(block.number, "CHIP::_writeCheckpoint: block number exceeds 32 bits");																									
																									
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {																									
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;																									
} else {																									
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);																									
numCheckpoints[delegatee] = nCheckpoints + 1;																									
}																									
																									
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);																									
}																									
																									
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {																									
require(n < 2**32, errorMessage);																									
return uint32(n);																									
}																									
																									
function getChainId() internal pure returns (uint) {																									
uint256 chainId;																									
assembly { chainId := chainid() }																									
return chainId;																									
}																									
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DELEGATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"airdrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"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":"","type":"address"},{"internalType":"uint32","name":"","type":"uint32"}],"name":"checkpoints","outputs":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint256","name":"votes","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":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegator","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getCurrentVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPriorVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"_to","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":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"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":"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"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

44369:13885:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26834:121;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30372:224;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;28564:138;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47334:122;;;:::i;:::-;;;;;;;;;;;;;;;;;;;31357:393;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;28271:121;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;32446:273;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;44591:217;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48710:259;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;49244:142;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;44862:935;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;47145:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;28872:157;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;43358:203;;;:::i;:::-;;52843:1845;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47882:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;42329:117;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;27201:125;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33549:324;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;29449:230;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;51843:382;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50047:1448;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;29849:189;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47617:117;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46939:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;43843:316;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;26834:121;26871:13;26921:5;26914:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26834:121;:::o;30372:224::-;30455:4;30489:39;30498:12;:10;:12::i;:::-;30512:7;30521:6;30489:8;:39::i;:::-;30563:4;30556:11;;30372:224;;;;:::o;28564:138::-;28617:7;28661:12;;28654:19;;28564:138;:::o;47334:122::-;47376:80;47334:122;:::o;31357:393::-;31463:4;31497:36;31507:6;31515:9;31526:6;31497:9;:36::i;:::-;31561:121;31570:6;31578:12;:10;:12::i;:::-;31592:89;31630:6;31592:89;;;;;;;;;;;;;;;;;:11;:19;31604:6;31592:19;;;;;;;;;;;;;;;:33;31612:12;:10;:12::i;:::-;31592:33;;;;;;;;;;;;;;;;:37;;:89;;;;;:::i;:::-;31561:8;:121::i;:::-;31717:4;31710:11;;31357:393;;;;;:::o;28271:121::-;28312:5;28354:9;;;;;;;;;;;28347:16;;28271:121;:::o;32446:273::-;32534:4;32568:83;32577:12;:10;:12::i;:::-;32591:7;32600:50;32639:10;32600:11;:25;32612:12;:10;:12::i;:::-;32600:25;;;;;;;;;;;;;;;:34;32626:7;32600:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;32568:8;:83::i;:::-;32686:4;32679:11;;32446:273;;;;:::o;44591:217::-;42713:12;:10;:12::i;:::-;42703:22;;:6;;;;;;;;;;;:22;;;42695:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44680:19:::1;44686:3;44691:7;44680:5;:19::i;:::-;44727:52;44750:1;44754:10;:15;44765:3;44754:15;;;;;;;;;;;;;;;;;;;;;;;;;44771:7;44727:14;:52::i;:::-;44591:217:::0;;:::o;48710:259::-;48849:7;48919:10;:21;48930:9;48919:21;;;;;;;;;;;;;;;;;;;;;;;;;48912:28;;48710:259;;;:::o;49244:142::-;49325:32;49335:10;49347:9;49325;:32::i;:::-;49244:142;:::o;44862:935::-;44959:4;42713:12;:10;:12::i;:::-;42703:22;;:6;;;;;;;;;;;:22;;;42695:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45020:1:::1;45001:9;:16;:20;:58;;;;;45045:7;:14;45025:9;:16;:34;45001:58;44993:67;;;::::0;::::1;;45115:19;45197:6:::0;45193:221:::1;45213:9;:16;45209:1;:20;45193:221;;;45284:1;45271:7;45279:1;45271:10;;;;;;;;;;;;;;:14;:44;;;;;45313:1;45289:26;;:9;45299:1;45289:12;;;;;;;;;;;;;;:26;;;;45271:44;45263:53;;;::::0;::::1;;45358:27;45374:7;45382:1;45374:10;;;;;;;;;;;;;;45358:11;:15;;:27;;;;:::i;:::-;45344:41;;45231:3;;;;;;;45193:221;;;;45501:11;45476:21;45486:10;45476:9;:21::i;:::-;:36;;45468:45;;;::::0;::::1;;45573:6;45568:135;45589:9;:16;45585:1;:20;45568:135;;;45640:34;45649:9;45659:1;45649:12;;;;;;;;;;;;;;45663:7;45671:1;45663:10;;;;;;;;;;;;;;45640:8;:34::i;:::-;;45607:3;;;;;;;45568:135;;;;45764:4;45757:11;;;44862:935:::0;;;;:::o;47145:49::-;;;;;;;;;;;;;;;;;;;;;;:::o;28872:157::-;28938:7;28982:9;:18;28992:7;28982:18;;;;;;;;;;;;;;;;28975:25;;28872:157;;;:::o;43358:203::-;42713:12;:10;:12::i;:::-;42703:22;;:6;;;;;;;;;;;:22;;;42695:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43482:1:::1;43445:40;;43466:6;;;;;;;;;;;43445:40;;;;;;;;;;;;43530:1;43513:6;;:19;;;;;;;;;;;;;;;;;;43358:203::o:0;52843:1845::-;53002:7;53087:12;53073:11;:26;53065:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53198:19;53220:14;:23;53235:7;53220:23;;;;;;;;;;;;;;;;;;;;;;;;;53198:45;;53291:1;53275:12;:17;;;53271:88;;;53329:1;53322:8;;;;;53271:88;53530:11;53478;:20;53490:7;53478:20;;;;;;;;;;;;;;;:38;53514:1;53499:12;:16;53478:38;;;;;;;;;;;;;;;:48;;;;;;;;;;;;:63;;;53474:177;;53578:11;:20;53590:7;53578:20;;;;;;;;;;;;;;;:38;53614:1;53599:12;:16;53578:38;;;;;;;;;;;;;;;:44;;;53571:51;;;;;53474:177;53807:11;53771;:20;53783:7;53771:20;;;;;;;;;;;;;;;:23;53792:1;53771:23;;;;;;;;;;;;;:33;;;;;;;;;;;;:47;;;53767:118;;;53855:1;53848:8;;;;;53767:118;53939:12;53983;54013:1;53998:12;:16;53983:31;;54042:550;54057:5;54049:13;;:5;:13;;;54042:550;;;54092:13;54134:1;54125:5;54117;:13;54116:19;;;;;;;;54108:5;:27;54092:43;;54190:20;;:::i;:::-;54213:11;:20;54225:7;54213:20;;;;;;;;;;;;;;;:28;54234:6;54213:28;;;;;;;;;;;;;;;54190:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54289:11;54273:2;:12;;;:27;;;54269:295;;;54337:2;:8;;;54330:15;;;;;;;;;54269:295;54399:11;54384:2;:12;;;:26;;;54380:184;;;54448:6;54440:14;;54380:184;;;54534:1;54525:6;:10;54517:18;;54380:184;54042:550;;;;;54626:11;:20;54638:7;54626:20;;;;;;;;;;;;;;;:27;54647:5;54626:27;;;;;;;;;;;;;;;:33;;;54619:40;;;;;52843:1845;;;;;:::o;47882:39::-;;;;;;;;;;;;;;;;;:::o;42329:117::-;42367:7;42411:6;;;;;;;;;;;42404:13;;42329:117;:::o;27201:125::-;27240:13;27290:7;27283:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27201:125;:::o;33549:324::-;33642:4;33676:129;33685:12;:10;:12::i;:::-;33699:7;33708:96;33747:15;33708:96;;;;;;;;;;;;;;;;;:11;:25;33720:12;:10;:12::i;:::-;33708:25;;;;;;;;;;;;;;;:34;33734:7;33708:34;;;;;;;;;;;;;;;;:38;;:96;;;;;:::i;:::-;33676:8;:129::i;:::-;33840:4;33833:11;;33549:324;;;;:::o;29449:230::-;29535:4;29569:42;29579:12;:10;:12::i;:::-;29593:9;29604:6;29569:9;:42::i;:::-;29646:4;29639:11;;29449:230;;;;:::o;51843:382::-;51986:7;52049:19;52071:14;:23;52086:7;52071:23;;;;;;;;;;;;;;;;;;;;;;;;;52049:45;;52144:1;52129:12;:16;;;:67;;52195:1;52129:67;;;52148:11;:20;52160:7;52148:20;;;;;;;;;;;;;;;:38;52184:1;52169:12;:16;52148:38;;;;;;;;;;;;;;;:44;;;52129:67;52122:74;;;51843:382;;;:::o;50047:1448::-;50418:23;47376:80;50578:6;:4;:6::i;:::-;50562:24;;;;;;50614:12;:10;:12::i;:::-;50662:4;50481:214;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50444:279;;;;;;50418:305;;50778:18;47663:71;50840:9;50850:5;50856:6;50809:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50799:65;;;;;;50778:86;;50919:14;50974:15;50990:10;50946:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50936:66;;;;;;50919:83;;51057:17;51077:26;51087:6;51095:1;51098;51101;51077:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51057:46;;51160:1;51139:23;;:9;:23;;;;51131:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51250:6;:17;51257:9;51250:17;;;;;;;;;;;;;;;;:19;;;;;;;;;;;;51241:5;:28;51233:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51351:6;51344:3;:13;;51336:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51435:31;51445:9;51456;51435;:31::i;:::-;51428:38;;;;50047:1448;;;;;;:::o;29849:189::-;29938:7;29982:11;:18;29994:5;29982:18;;;;;;;;;;;;;;;:27;30001:7;29982:27;;;;;;;;;;;;;;;;29975:34;;29849:189;;;;:::o;47617:117::-;47663:71;47617:117;:::o;46939:70::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43843:316::-;42713:12;:10;:12::i;:::-;42703:22;;:6;;;;;;;;;;;:22;;;42695:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43969:1:::1;43949:22;;:8;:22;;;;43941:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44076:8;44047:38;;44068:6;;;;;;;;;;;44047:38;;;;;;;;;;;;44122:8;44113:6;;:17;;;;;;;;;;;;;;;;;;43843:316:::0;:::o;967:144::-;1020:15;1072:10;1065:17;;967:144;:::o;38364:460::-;38500:1;38483:19;;:5;:19;;;;38475:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38598:1;38579:21;;:7;:21;;;;38571:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38724:6;38694:11;:18;38706:5;38694:18;;;;;;;;;;;;;;;:27;38713:7;38694:27;;;;;;;;;;;;;;;:36;;;;38779:7;38763:32;;38772:5;38763:32;;;38788:6;38763:32;;;;;;;;;;;;;;;;;;38364:460;;;:::o;34690:712::-;34831:1;34813:20;;:6;:20;;;;34805:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34932:1;34911:23;;:9;:23;;;;34903:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35029:47;35050:6;35058:9;35069:6;35029:20;:47::i;:::-;35151:71;35173:6;35151:71;;;;;;;;;;;;;;;;;:9;:17;35161:6;35151:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;35131:9;:17;35141:6;35131:17;;;;;;;;;;;;;;;:91;;;;35273:32;35298:6;35273:9;:20;35283:9;35273:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;35250:9;:20;35260:9;35250:20;;;;;;;;;;;;;;;:55;;;;35355:9;35338:35;;35347:6;35338:35;;;35366:6;35338:35;;;;;;;;;;;;;;;;;;34690:712;;;:::o;8895:289::-;8981:7;9031:1;9026;:6;;9034:12;9018:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9075:9;9091:1;9087;:5;9075:17;;9154:1;9147:8;;;8895:289;;;;;:::o;7363:278::-;7421:7;7458:9;7474:1;7470;:5;7458:17;;7516:1;7511;:6;;7503:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7611:1;7604:8;;;7363:278;;;;:::o;35910:534::-;36030:1;36011:21;;:7;:21;;;;36003:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36123:49;36152:1;36156:7;36165:6;36123:20;:49::i;:::-;36242:24;36259:6;36242:12;;:16;;:24;;;;:::i;:::-;36227:12;:39;;;;36315:30;36338:6;36315:9;:18;36325:7;36315:18;;;;;;;;;;;;;;;;:22;;:30;;;;:::i;:::-;36294:9;:18;36304:7;36294:18;;;;;;;;;;;;;;;:51;;;;36399:7;36378:37;;36395:1;36378:37;;;36408:6;36378:37;;;;;;;;;;;;;;;;;;35910:534;;:::o;55428:1169::-;55551:6;55541:16;;:6;:16;;;;:30;;;;;55570:1;55561:6;:10;55541:30;55537:1032;;;55623:1;55605:20;;:6;:20;;;55601:443;;55712:16;55731:14;:22;55746:6;55731:22;;;;;;;;;;;;;;;;;;;;;;;;;55712:41;;55781:17;55813:1;55801:9;:13;;;:60;;55860:1;55801:60;;;55817:11;:19;55829:6;55817:19;;;;;;;;;;;;;;;:34;55849:1;55837:9;:13;55817:34;;;;;;;;;;;;;;;:40;;;55801:60;55781:80;;55889:17;55909:21;55923:6;55909:9;:13;;:21;;;;:::i;:::-;55889:41;;55958:57;55975:6;55983:9;55994;56005;55958:16;:57::i;:::-;55601:443;;;;56120:1;56102:20;;:6;:20;;;56098:443;;56209:16;56228:14;:22;56243:6;56228:22;;;;;;;;;;;;;;;;;;;;;;;;;56209:41;;56278:17;56310:1;56298:9;:13;;;:60;;56357:1;56298:60;;;56314:11;:19;56326:6;56314:19;;;;;;;;;;;;;;;:34;56346:1;56334:9;:13;56314:34;;;;;;;;;;;;;;;:40;;;56298:60;56278:80;;56386:17;56406:21;56420:6;56406:9;:13;;:21;;;;:::i;:::-;56386:41;;56455:57;56472:6;56480:9;56491;56502;56455:16;:57::i;:::-;56098:443;;;;55537:1032;55428:1169;;;:::o;54742:632::-;54888:23;54914:10;:21;54925:9;54914:21;;;;;;;;;;;;;;;;;;;;;;;;;54888:47;;54963:24;54990:20;55000:9;54990;:20::i;:::-;54963:47;;55107:9;55083:10;:21;55094:9;55083:21;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;55220:9;55176:54;;55203:15;55176:54;;55192:9;55176:54;;;;;;;;;;;;55285:60;55300:15;55317:9;55328:16;55285:14;:60::i;:::-;54742:632;;;;:::o;58001:225::-;58046:4;58080:15;58145:9;58134:20;;58190:7;58183:14;;;58001:225;:::o;40401:92::-;;;;:::o;8171:174::-;8229:7;8273:43;8277:1;8280;8273:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;8266:50;;8171:174;;;;:::o;56651:1026::-;56974:18;56995:76;57002:12;56995:76;;;;;;;;;;;;;;;;;:6;:76::i;:::-;56974:97;;57145:1;57130:12;:16;;;:85;;;;;57204:11;57150:65;;:11;:22;57162:9;57150:22;;;;;;;;;;;;;;;:40;57188:1;57173:12;:16;57150:40;;;;;;;;;;;;;;;:50;;;;;;;;;;;;:65;;;57130:85;57126:412;;;57294:8;57245:11;:22;57257:9;57245:22;;;;;;;;;;;;;;;:40;57283:1;57268:12;:16;57245:40;;;;;;;;;;;;;;;:46;;:57;;;;57126:412;;;57404:33;;;;;;;;57415:11;57404:33;;;;;;57428:8;57404:33;;;57365:11;:22;57377:9;57365:22;;;;;;;;;;;;;;;:36;57388:12;57365:36;;;;;;;;;;;;;;;:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57508:1;57493:12;:16;57465:14;:25;57480:9;57465:25;;;;;;;;;;;;;;;;:44;;;;;;;;;;;;;;;;;;57126:412;57618:9;57597:51;;;57629:8;57639;57597:51;;;;;;;;;;;;;;;;;;;;;;;;56651:1026;;;;;:::o;57731:216::-;57806:6;57854:5;57850:1;:9;57861:12;57842:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57916:1;57902:16;;57731:216;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;:::o

ipfs://b14381bbceec5579f0a207126ad12ec03259bcdf7300d880e04ff38d85ed7d7a