file_name
stringlengths 71
779k
| comments
stringlengths 20
182k
| code_string
stringlengths 20
36.9M
| __index_level_0__
int64 0
17.2M
| input_ids
sequence | attention_mask
sequence | labels
sequence |
|---|---|---|---|---|---|---|
./full_match/80001/0xcb77Bf500f84df25516F5ee09440D505542A3F4E/sources/contracts/ERC721Upgradeable.sol | * the Metadata extension, but not including the Enumerable extension, which is available separately as {ERC721Enumerable}./ Token name Token symbol Mapping from token ID to owner address Mapping owner address to token count Mapping from token ID to approved address Mapping from owner to operator approvals | contract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {
using AddressUpgradeable for address;
using StringsUpgradeable for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC721_init_unchained(name_, symbol_);
}
function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC721Upgradeable).interfaceId ||
interfaceId == type(IERC721MetadataUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721Upgradeable.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(tokenId) != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721Upgradeable.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId, 1);
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId, 1);
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721Upgradeable.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
owner = ERC721Upgradeable.ownerOf(tokenId);
delete _tokenApprovals[tokenId];
unchecked {
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721Upgradeable.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
owner = ERC721Upgradeable.ownerOf(tokenId);
delete _tokenApprovals[tokenId];
unchecked {
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
delete _tokenApprovals[tokenId];
unchecked {
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
delete _tokenApprovals[tokenId];
unchecked {
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
assembly {
revert(add(32, reason), mload(reason))
}
}
}
return true;
}
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
assembly {
revert(add(32, reason), mload(reason))
}
}
}
return true;
}
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
assembly {
revert(add(32, reason), mload(reason))
}
}
}
return true;
}
}
} catch (bytes memory reason) {
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
assembly {
revert(add(32, reason), mload(reason))
}
}
}
return true;
}
}
} else {
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
assembly {
revert(add(32, reason), mload(reason))
}
}
}
return true;
}
}
} else {
function _beforeTokenTransfer(
address from,
address to,
uint256, /* firstTokenId */
uint256 batchSize
) internal virtual {
if (batchSize > 1) {
if (from != address(0)) {
_balances[from] -= batchSize;
}
if (to != address(0)) {
_balances[to] += batchSize;
}
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256, /* firstTokenId */
uint256 batchSize
) internal virtual {
if (batchSize > 1) {
if (from != address(0)) {
_balances[from] -= batchSize;
}
if (to != address(0)) {
_balances[to] += batchSize;
}
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256, /* firstTokenId */
uint256 batchSize
) internal virtual {
if (batchSize > 1) {
if (from != address(0)) {
_balances[from] -= batchSize;
}
if (to != address(0)) {
_balances[to] += batchSize;
}
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256, /* firstTokenId */
uint256 batchSize
) internal virtual {
if (batchSize > 1) {
if (from != address(0)) {
_balances[from] -= batchSize;
}
if (to != address(0)) {
_balances[to] += batchSize;
}
}
}
) internal virtual {}
} | 9,463,667 | [
1,
5787,
6912,
2710,
16,
1496,
486,
6508,
326,
6057,
25121,
2710,
16,
1492,
353,
2319,
18190,
487,
288,
654,
39,
27,
5340,
3572,
25121,
5496,
19,
3155,
508,
3155,
3273,
9408,
628,
1147,
1599,
358,
3410,
1758,
9408,
3410,
1758,
358,
1147,
1056,
9408,
628,
1147,
1599,
358,
20412,
1758,
9408,
628,
3410,
358,
3726,
6617,
4524,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
4232,
39,
27,
5340,
10784,
429,
353,
10188,
6934,
16,
1772,
10784,
429,
16,
4232,
39,
28275,
10784,
429,
16,
467,
654,
39,
27,
5340,
10784,
429,
16,
467,
654,
39,
27,
5340,
2277,
10784,
429,
288,
203,
565,
1450,
5267,
10784,
429,
364,
1758,
31,
203,
565,
1450,
8139,
10784,
429,
364,
2254,
5034,
31,
203,
203,
565,
533,
3238,
389,
529,
31,
203,
203,
565,
533,
3238,
389,
7175,
31,
203,
203,
565,
2874,
12,
11890,
5034,
516,
1758,
13,
3238,
389,
995,
414,
31,
203,
203,
565,
2874,
12,
2867,
516,
2254,
5034,
13,
3238,
389,
70,
26488,
31,
203,
203,
565,
2874,
12,
11890,
5034,
516,
1758,
13,
3238,
389,
2316,
12053,
4524,
31,
203,
203,
565,
2874,
12,
2867,
516,
2874,
12,
2867,
516,
1426,
3719,
3238,
389,
9497,
12053,
4524,
31,
203,
203,
203,
565,
445,
1001,
654,
39,
27,
5340,
67,
2738,
12,
1080,
3778,
508,
67,
16,
533,
3778,
3273,
67,
13,
2713,
1338,
29782,
288,
203,
3639,
1001,
654,
39,
27,
5340,
67,
2738,
67,
4384,
8707,
12,
529,
67,
16,
3273,
67,
1769,
203,
565,
289,
203,
203,
565,
445,
1001,
654,
39,
27,
5340,
67,
2738,
67,
4384,
8707,
12,
1080,
3778,
508,
67,
16,
533,
3778,
3273,
67,
13,
2713,
1338,
29782,
288,
203,
3639,
389,
529,
273,
508,
67,
31,
203,
3639,
389,
7175,
273,
3273,
67,
31,
203,
565,
289,
203,
203,
565,
445,
6146,
1358,
12,
3890,
24,
1560,
548,
13,
1071,
1476,
5024,
3849,
12,
654,
39,
2
] |
// SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
pragma experimental ABIEncoderV2;
abstract contract IManager {
function last(address) virtual public returns (uint);
function cdpCan(address, uint, address) virtual public view returns (uint);
function ilks(uint) virtual public view returns (bytes32);
function owns(uint) virtual public view returns (address);
function urns(uint) virtual public view returns (address);
function vat() virtual public view returns (address);
function open(bytes32, address) virtual public returns (uint);
function give(uint, address) virtual public;
function cdpAllow(uint, address, uint) virtual public;
function urnAllow(address, uint) virtual public;
function frob(uint, int, int) virtual public;
function flux(uint, address, uint) virtual public;
function move(uint, address, uint) virtual public;
function exit(address, uint, address, uint) virtual public;
function quit(uint, address) virtual public;
function enter(address, uint) virtual public;
function shift(uint, uint) virtual public;
}
abstract contract IVat {
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
mapping (bytes32 => mapping (address => Urn )) public urns;
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => uint)) public gem; // [wad]
function can(address, address) virtual public view returns (uint);
function dai(address) virtual public view returns (uint);
function frob(bytes32, address, address, address, int, int) virtual public;
function hope(address) virtual public;
function move(address, address, uint) virtual public;
function fork(bytes32, address, address, int, int) virtual public;
}
abstract contract IGem {
function dec() virtual public returns (uint);
function gem() virtual public returns (IGem);
function join(address, uint) virtual public payable;
function exit(address, uint) virtual public;
function approve(address, uint) virtual public;
function transfer(address, uint) virtual public returns (bool);
function transferFrom(address, address, uint) virtual public returns (bool);
function deposit() virtual public payable;
function withdraw(uint) virtual public;
function allowance(address, address) virtual public returns (uint);
}
abstract contract IJoin {
bytes32 public ilk;
function dec() virtual public view returns (uint);
function gem() virtual public view returns (IGem);
function join(address, uint) virtual public payable;
function exit(address, uint) virtual public;
}
interface IERC20 {
function totalSupply() external view returns (uint256 supply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(
address _from,
address _to,
uint256 _value
) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
function decimals() external view returns (uint256 digits);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
abstract contract IWETH {
function allowance(address, address) public virtual returns (uint256);
function balanceOf(address) public virtual returns (uint256);
function approve(address, uint256) public virtual;
function transfer(address, uint256) public virtual returns (bool);
function transferFrom(
address,
address,
uint256
) public virtual returns (bool);
function deposit() public payable virtual;
function withdraw(uint256) public virtual;
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return
functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(
token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
);
}
/// @dev Edited so it always first approves 0 and then the value, because of non standard tokens
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(
token,
abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
);
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(
value,
"SafeERC20: decreased allowance below zero"
);
_callOptionalReturn(
token,
abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
);
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(
data,
"SafeERC20: low-level call failed"
);
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library TokenUtils {
using SafeERC20 for IERC20;
address public constant WETH_ADDR = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address public constant ETH_ADDR = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
function approveToken(
address _tokenAddr,
address _to,
uint256 _amount
) internal {
if (_tokenAddr == ETH_ADDR) return;
if (IERC20(_tokenAddr).allowance(address(this), _to) < _amount) {
IERC20(_tokenAddr).safeApprove(_to, _amount);
}
}
function pullTokensIfNeeded(
address _token,
address _from,
uint256 _amount
) internal returns (uint256) {
// handle max uint amount
if (_amount == type(uint256).max) {
uint256 userAllowance = IERC20(_token).allowance(_from, address(this));
uint256 balance = getBalance(_token, _from);
// pull max allowance amount if balance is bigger than allowance
_amount = (balance > userAllowance) ? userAllowance : balance;
}
if (_from != address(0) && _from != address(this) && _token != ETH_ADDR && _amount != 0) {
IERC20(_token).safeTransferFrom(_from, address(this), _amount);
}
return _amount;
}
function withdrawTokens(
address _token,
address _to,
uint256 _amount
) internal returns (uint256) {
if (_amount == type(uint256).max) {
_amount = getBalance(_token, address(this));
}
if (_to != address(0) && _to != address(this) && _amount != 0) {
if (_token != ETH_ADDR) {
IERC20(_token).safeTransfer(_to, _amount);
} else {
payable(_to).transfer(_amount);
}
}
return _amount;
}
function depositWeth(uint256 _amount) internal {
IWETH(WETH_ADDR).deposit{value: _amount}();
}
function withdrawWeth(uint256 _amount) internal {
IWETH(WETH_ADDR).withdraw(_amount);
}
function getBalance(address _tokenAddr, address _acc) internal view returns (uint256) {
if (_tokenAddr == ETH_ADDR) {
return _acc.balance;
} else {
return IERC20(_tokenAddr).balanceOf(_acc);
}
}
function getTokenDecimals(address _token) internal view returns (uint256) {
if (_token == ETH_ADDR) return 18;
return IERC20(_token).decimals();
}
}
abstract contract IDFSRegistry {
function getAddr(bytes32 _id) public view virtual returns (address);
function addNewContract(
bytes32 _id,
address _contractAddr,
uint256 _waitPeriod
) public virtual;
function startContractChange(bytes32 _id, address _newContractAddr) public virtual;
function approveContractChange(bytes32 _id) public virtual;
function cancelContractChange(bytes32 _id) public virtual;
function changeWaitPeriod(bytes32 _id, uint256 _newWaitPeriod) public virtual;
}
/// @title A stateful contract that holds and can change owner/admin
contract AdminVault {
address public owner;
address public admin;
constructor() {
owner = msg.sender;
admin = 0x25eFA336886C74eA8E282ac466BdCd0199f85BB9;
}
/// @notice Admin is able to change owner
/// @param _owner Address of new owner
function changeOwner(address _owner) public {
require(admin == msg.sender, "msg.sender not admin");
owner = _owner;
}
/// @notice Admin is able to set new admin
/// @param _admin Address of multisig that becomes new admin
function changeAdmin(address _admin) public {
require(admin == msg.sender, "msg.sender not admin");
admin = _admin;
}
}
/// @title AdminAuth Handles owner/admin privileges over smart contracts
contract AdminAuth {
using SafeERC20 for IERC20;
AdminVault public constant adminVault = AdminVault(0xCCf3d848e08b94478Ed8f46fFead3008faF581fD);
modifier onlyOwner() {
require(adminVault.owner() == msg.sender, "msg.sender not owner");
_;
}
modifier onlyAdmin() {
require(adminVault.admin() == msg.sender, "msg.sender not admin");
_;
}
/// @notice withdraw stuck funds
function withdrawStuckFunds(address _token, address _receiver, uint256 _amount) public onlyOwner {
if (_token == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
payable(_receiver).transfer(_amount);
} else {
IERC20(_token).safeTransfer(_receiver, _amount);
}
}
/// @notice Destroy the contract
function kill() public onlyAdmin {
selfdestruct(payable(msg.sender));
}
}
contract DefisaverLogger {
event LogEvent(
address indexed contractAddress,
address indexed caller,
string indexed logName,
bytes data
);
// solhint-disable-next-line func-name-mixedcase
function Log(
address _contract,
address _caller,
string memory _logName,
bytes memory _data
) public {
emit LogEvent(_contract, _caller, _logName, _data);
}
}
/// @title Stores all the important DFS addresses and can be changed (timelock)
contract DFSRegistry is AdminAuth {
DefisaverLogger public constant logger = DefisaverLogger(
0x5c55B921f590a89C1Ebe84dF170E655a82b62126
);
string public constant ERR_ENTRY_ALREADY_EXISTS = "Entry id already exists";
string public constant ERR_ENTRY_NON_EXISTENT = "Entry id doesn't exists";
string public constant ERR_ENTRY_NOT_IN_CHANGE = "Entry not in change process";
string public constant ERR_WAIT_PERIOD_SHORTER = "New wait period must be bigger";
string public constant ERR_CHANGE_NOT_READY = "Change not ready yet";
string public constant ERR_EMPTY_PREV_ADDR = "Previous addr is 0";
string public constant ERR_ALREADY_IN_CONTRACT_CHANGE = "Already in contract change";
string public constant ERR_ALREADY_IN_WAIT_PERIOD_CHANGE = "Already in wait period change";
struct Entry {
address contractAddr;
uint256 waitPeriod;
uint256 changeStartTime;
bool inContractChange;
bool inWaitPeriodChange;
bool exists;
}
mapping(bytes32 => Entry) public entries;
mapping(bytes32 => address) public previousAddresses;
mapping(bytes32 => address) public pendingAddresses;
mapping(bytes32 => uint256) public pendingWaitTimes;
/// @notice Given an contract id returns the registered address
/// @dev Id is keccak256 of the contract name
/// @param _id Id of contract
function getAddr(bytes32 _id) public view returns (address) {
return entries[_id].contractAddr;
}
/// @notice Helper function to easily query if id is registered
/// @param _id Id of contract
function isRegistered(bytes32 _id) public view returns (bool) {
return entries[_id].exists;
}
/////////////////////////// OWNER ONLY FUNCTIONS ///////////////////////////
/// @notice Adds a new contract to the registry
/// @param _id Id of contract
/// @param _contractAddr Address of the contract
/// @param _waitPeriod Amount of time to wait before a contract address can be changed
function addNewContract(
bytes32 _id,
address _contractAddr,
uint256 _waitPeriod
) public onlyOwner {
require(!entries[_id].exists, ERR_ENTRY_ALREADY_EXISTS);
entries[_id] = Entry({
contractAddr: _contractAddr,
waitPeriod: _waitPeriod,
changeStartTime: 0,
inContractChange: false,
inWaitPeriodChange: false,
exists: true
});
// Remember tha address so we can revert back to old addr if needed
previousAddresses[_id] = _contractAddr;
logger.Log(
address(this),
msg.sender,
"AddNewContract",
abi.encode(_id, _contractAddr, _waitPeriod)
);
}
/// @notice Reverts to the previous address immediately
/// @dev In case the new version has a fault, a quick way to fallback to the old contract
/// @param _id Id of contract
function revertToPreviousAddress(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(previousAddresses[_id] != address(0), ERR_EMPTY_PREV_ADDR);
address currentAddr = entries[_id].contractAddr;
entries[_id].contractAddr = previousAddresses[_id];
logger.Log(
address(this),
msg.sender,
"RevertToPreviousAddress",
abi.encode(_id, currentAddr, previousAddresses[_id])
);
}
/// @notice Starts an address change for an existing entry
/// @dev Can override a change that is currently in progress
/// @param _id Id of contract
/// @param _newContractAddr Address of the new contract
function startContractChange(bytes32 _id, address _newContractAddr) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(!entries[_id].inWaitPeriodChange, ERR_ALREADY_IN_WAIT_PERIOD_CHANGE);
entries[_id].changeStartTime = block.timestamp; // solhint-disable-line
entries[_id].inContractChange = true;
pendingAddresses[_id] = _newContractAddr;
logger.Log(
address(this),
msg.sender,
"StartContractChange",
abi.encode(_id, entries[_id].contractAddr, _newContractAddr)
);
}
/// @notice Changes new contract address, correct time must have passed
/// @param _id Id of contract
function approveContractChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inContractChange, ERR_ENTRY_NOT_IN_CHANGE);
require(
block.timestamp >= (entries[_id].changeStartTime + entries[_id].waitPeriod), // solhint-disable-line
ERR_CHANGE_NOT_READY
);
address oldContractAddr = entries[_id].contractAddr;
entries[_id].contractAddr = pendingAddresses[_id];
entries[_id].inContractChange = false;
entries[_id].changeStartTime = 0;
pendingAddresses[_id] = address(0);
previousAddresses[_id] = oldContractAddr;
logger.Log(
address(this),
msg.sender,
"ApproveContractChange",
abi.encode(_id, oldContractAddr, entries[_id].contractAddr)
);
}
/// @notice Cancel pending change
/// @param _id Id of contract
function cancelContractChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inContractChange, ERR_ENTRY_NOT_IN_CHANGE);
address oldContractAddr = pendingAddresses[_id];
pendingAddresses[_id] = address(0);
entries[_id].inContractChange = false;
entries[_id].changeStartTime = 0;
logger.Log(
address(this),
msg.sender,
"CancelContractChange",
abi.encode(_id, oldContractAddr, entries[_id].contractAddr)
);
}
/// @notice Starts the change for waitPeriod
/// @param _id Id of contract
/// @param _newWaitPeriod New wait time
function startWaitPeriodChange(bytes32 _id, uint256 _newWaitPeriod) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(!entries[_id].inContractChange, ERR_ALREADY_IN_CONTRACT_CHANGE);
pendingWaitTimes[_id] = _newWaitPeriod;
entries[_id].changeStartTime = block.timestamp; // solhint-disable-line
entries[_id].inWaitPeriodChange = true;
logger.Log(
address(this),
msg.sender,
"StartWaitPeriodChange",
abi.encode(_id, _newWaitPeriod)
);
}
/// @notice Changes new wait period, correct time must have passed
/// @param _id Id of contract
function approveWaitPeriodChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inWaitPeriodChange, ERR_ENTRY_NOT_IN_CHANGE);
require(
block.timestamp >= (entries[_id].changeStartTime + entries[_id].waitPeriod), // solhint-disable-line
ERR_CHANGE_NOT_READY
);
uint256 oldWaitTime = entries[_id].waitPeriod;
entries[_id].waitPeriod = pendingWaitTimes[_id];
entries[_id].inWaitPeriodChange = false;
entries[_id].changeStartTime = 0;
pendingWaitTimes[_id] = 0;
logger.Log(
address(this),
msg.sender,
"ApproveWaitPeriodChange",
abi.encode(_id, oldWaitTime, entries[_id].waitPeriod)
);
}
/// @notice Cancel wait period change
/// @param _id Id of contract
function cancelWaitPeriodChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inWaitPeriodChange, ERR_ENTRY_NOT_IN_CHANGE);
uint256 oldWaitPeriod = pendingWaitTimes[_id];
pendingWaitTimes[_id] = 0;
entries[_id].inWaitPeriodChange = false;
entries[_id].changeStartTime = 0;
logger.Log(
address(this),
msg.sender,
"CancelWaitPeriodChange",
abi.encode(_id, oldWaitPeriod, entries[_id].waitPeriod)
);
}
}
/// @title Implements Action interface and common helpers for passing inputs
abstract contract ActionBase is AdminAuth {
address public constant REGISTRY_ADDR = 0xD6049E1F5F3EfF1F921f5532aF1A1632bA23929C;
DFSRegistry public constant registry = DFSRegistry(REGISTRY_ADDR);
DefisaverLogger public constant logger = DefisaverLogger(
0x5c55B921f590a89C1Ebe84dF170E655a82b62126
);
string public constant ERR_SUB_INDEX_VALUE = "Wrong sub index value";
string public constant ERR_RETURN_INDEX_VALUE = "Wrong return index value";
/// @dev Subscription params index range [128, 255]
uint8 public constant SUB_MIN_INDEX_VALUE = 128;
uint8 public constant SUB_MAX_INDEX_VALUE = 255;
/// @dev Return params index range [1, 127]
uint8 public constant RETURN_MIN_INDEX_VALUE = 1;
uint8 public constant RETURN_MAX_INDEX_VALUE = 127;
/// @dev If the input value should not be replaced
uint8 public constant NO_PARAM_MAPPING = 0;
/// @dev We need to parse Flash loan actions in a different way
enum ActionType { FL_ACTION, STANDARD_ACTION, CUSTOM_ACTION }
/// @notice Parses inputs and runs the implemented action through a proxy
/// @dev Is called by the TaskExecutor chaining actions together
/// @param _callData Array of input values each value encoded as bytes
/// @param _subData Array of subscribed vales, replaces input values if specified
/// @param _paramMapping Array that specifies how return and subscribed values are mapped in input
/// @param _returnValues Returns values from actions before, which can be injected in inputs
/// @return Returns a bytes32 value through DSProxy, each actions implements what that value is
function executeAction(
bytes[] memory _callData,
bytes[] memory _subData,
uint8[] memory _paramMapping,
bytes32[] memory _returnValues
) public payable virtual returns (bytes32);
/// @notice Parses inputs and runs the single implemented action through a proxy
/// @dev Used to save gas when executing a single action directly
function executeActionDirect(bytes[] memory _callData) public virtual payable;
/// @notice Returns the type of action we are implementing
function actionType() public pure virtual returns (uint8);
//////////////////////////// HELPER METHODS ////////////////////////////
/// @notice Given an uint256 input, injects return/sub values if specified
/// @param _param The original input value
/// @param _mapType Indicated the type of the input in paramMapping
/// @param _subData Array of subscription data we can replace the input value with
/// @param _returnValues Array of subscription data we can replace the input value with
function _parseParamUint(
uint _param,
uint8 _mapType,
bytes[] memory _subData,
bytes32[] memory _returnValues
) internal pure returns (uint) {
if (isReplaceable(_mapType)) {
if (isReturnInjection(_mapType)) {
_param = uint(_returnValues[getReturnIndex(_mapType)]);
} else {
_param = abi.decode(_subData[getSubIndex(_mapType)], (uint));
}
}
return _param;
}
/// @notice Given an addr input, injects return/sub values if specified
/// @param _param The original input value
/// @param _mapType Indicated the type of the input in paramMapping
/// @param _subData Array of subscription data we can replace the input value with
/// @param _returnValues Array of subscription data we can replace the input value with
function _parseParamAddr(
address _param,
uint8 _mapType,
bytes[] memory _subData,
bytes32[] memory _returnValues
) internal pure returns (address) {
if (isReplaceable(_mapType)) {
if (isReturnInjection(_mapType)) {
_param = address(bytes20((_returnValues[getReturnIndex(_mapType)])));
} else {
_param = abi.decode(_subData[getSubIndex(_mapType)], (address));
}
}
return _param;
}
/// @notice Given an bytes32 input, injects return/sub values if specified
/// @param _param The original input value
/// @param _mapType Indicated the type of the input in paramMapping
/// @param _subData Array of subscription data we can replace the input value with
/// @param _returnValues Array of subscription data we can replace the input value with
function _parseParamABytes32(
bytes32 _param,
uint8 _mapType,
bytes[] memory _subData,
bytes32[] memory _returnValues
) internal pure returns (bytes32) {
if (isReplaceable(_mapType)) {
if (isReturnInjection(_mapType)) {
_param = (_returnValues[getReturnIndex(_mapType)]);
} else {
_param = abi.decode(_subData[getSubIndex(_mapType)], (bytes32));
}
}
return _param;
}
/// @notice Checks if the paramMapping value indicated that we need to inject values
/// @param _type Indicated the type of the input
function isReplaceable(uint8 _type) internal pure returns (bool) {
return _type != NO_PARAM_MAPPING;
}
/// @notice Checks if the paramMapping value is in the return value range
/// @param _type Indicated the type of the input
function isReturnInjection(uint8 _type) internal pure returns (bool) {
return (_type >= RETURN_MIN_INDEX_VALUE) && (_type <= RETURN_MAX_INDEX_VALUE);
}
/// @notice Transforms the paramMapping value to the index in return array value
/// @param _type Indicated the type of the input
function getReturnIndex(uint8 _type) internal pure returns (uint8) {
require(isReturnInjection(_type), ERR_SUB_INDEX_VALUE);
return (_type - RETURN_MIN_INDEX_VALUE);
}
/// @notice Transforms the paramMapping value to the index in sub array value
/// @param _type Indicated the type of the input
function getSubIndex(uint8 _type) internal pure returns (uint8) {
require(_type >= SUB_MIN_INDEX_VALUE, ERR_RETURN_INDEX_VALUE);
return (_type - SUB_MIN_INDEX_VALUE);
}
}
contract DSMath {
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x, "");
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x, "");
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "");
}
function div(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x / y;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x <= y ? x : y;
}
function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x >= y ? x : y;
}
function imin(int256 x, int256 y) internal pure returns (int256 z) {
return x <= y ? x : y;
}
function imax(int256 x, int256 y) internal pure returns (int256 z) {
return x >= y ? x : y;
}
uint256 constant WAD = 10**18;
uint256 constant RAY = 10**27;
function wmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint256 x, uint256 n) internal pure returns (uint256 z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
abstract contract DSAuthority {
function canCall(
address src,
address dst,
bytes4 sig
) public view virtual returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority(address indexed authority);
event LogSetOwner(address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_) public auth {
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_) public auth {
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "Not authorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
assembly {
foo := calldataload(4)
bar := calldataload(36)
}
emit LogNote(msg.sig, msg.sender, foo, bar, msg.value, msg.data);
_;
}
}
abstract contract DSProxy is DSAuth, DSNote {
DSProxyCache public cache; // global cache for contracts
constructor(address _cacheAddr) {
require(setCache(_cacheAddr), "Cache not set");
}
// solhint-disable-next-line no-empty-blocks
receive() external payable {}
// use the proxy to execute calldata _data on contract _code
function execute(bytes memory _code, bytes memory _data)
public
payable
virtual
returns (address target, bytes32 response);
function execute(address _target, bytes memory _data)
public
payable
virtual
returns (bytes32 response);
//set new cache
function setCache(address _cacheAddr) public payable virtual returns (bool);
}
contract DSProxyCache {
mapping(bytes32 => address) cache;
function read(bytes memory _code) public view returns (address) {
bytes32 hash = keccak256(_code);
return cache[hash];
}
function write(bytes memory _code) public returns (address target) {
assembly {
target := create(0, add(_code, 0x20), mload(_code))
switch iszero(extcodesize(target))
case 1 {
// throw if contract failed to deploy
revert(0, 0)
}
}
bytes32 hash = keccak256(_code);
cache[hash] = target;
}
}
/// @title Helper methods for MCDSaverProxy
contract McdHelper is DSMath {
IVat public constant vat = IVat(0x35D1b3F3D7966A1DFe207aa4514C12a259A0492B);
address public constant DAI_JOIN_ADDR = 0x9759A6Ac90977b93B58547b4A71c78317f391A28;
address public constant DAI_ADDR = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
/// @notice Returns a normalized debt _amount based on the current rate
/// @param _amount Amount of dai to be normalized
/// @param _rate Current rate of the stability fee
/// @param _daiVatBalance Balance od Dai in the Vat for that CDP
function normalizeDrawAmount(uint _amount, uint _rate, uint _daiVatBalance) internal pure returns (int dart) {
if (_daiVatBalance < mul(_amount, RAY)) {
dart = toPositiveInt(sub(mul(_amount, RAY), _daiVatBalance) / _rate);
dart = mul(uint(dart), _rate) < mul(_amount, RAY) ? dart + 1 : dart;
}
}
/// @notice Converts a number to Rad precision
/// @param _wad The input number in wad precision
function toRad(uint _wad) internal pure returns (uint) {
return mul(_wad, 10 ** 27);
}
/// @notice Converts a number to 18 decimal precision
/// @dev If token decimal is bigger than 18, function reverts
/// @param _joinAddr Join address of the collateral
/// @param _amount Number to be converted
function convertTo18(address _joinAddr, uint256 _amount) internal view returns (uint256) {
return mul(_amount, 10 ** sub(18 , IJoin(_joinAddr).dec()));
}
/// @notice Converts a uint to int and checks if positive
/// @param _x Number to be converted
function toPositiveInt(uint _x) internal pure returns (int y) {
y = int(_x);
require(y >= 0, "int-overflow");
}
/// @notice Gets Dai amount in Vat which can be added to Cdp
/// @param _vat Address of Vat contract
/// @param _urn Urn of the Cdp
/// @param _ilk Ilk of the Cdp
function normalizePaybackAmount(address _vat, address _urn, bytes32 _ilk) internal view returns (int amount) {
uint dai = IVat(_vat).dai(_urn);
(, uint rate,,,) = IVat(_vat).ilks(_ilk);
(, uint art) = IVat(_vat).urns(_ilk, _urn);
amount = toPositiveInt(dai / rate);
amount = uint(amount) <= art ? - amount : - toPositiveInt(art);
}
/// @notice Gets the whole debt of the CDP
/// @param _vat Address of Vat contract
/// @param _usr Address of the Dai holder
/// @param _urn Urn of the Cdp
/// @param _ilk Ilk of the Cdp
function getAllDebt(address _vat, address _usr, address _urn, bytes32 _ilk) internal view returns (uint daiAmount) {
(, uint rate,,,) = IVat(_vat).ilks(_ilk);
(, uint art) = IVat(_vat).urns(_ilk, _urn);
uint dai = IVat(_vat).dai(_usr);
uint rad = sub(mul(art, rate), dai);
daiAmount = rad / RAY;
// handles precision error (off by 1 wei)
daiAmount = mul(daiAmount, RAY) < rad ? daiAmount + 1 : daiAmount;
}
/// @notice Checks if the join address is one of the Ether coll. types
/// @param _joinAddr Join address to check
function isEthJoinAddr(address _joinAddr) internal view returns (bool) {
// if it's dai_join_addr don't check gem() it will fail
if (_joinAddr == DAI_JOIN_ADDR) return false;
// if coll is weth it's and eth type coll
if (address(IJoin(_joinAddr).gem()) == TokenUtils.WETH_ADDR) {
return true;
}
return false;
}
/// @notice Returns the underlying token address from the joinAddr
/// @dev For eth based collateral returns 0xEee... not weth addr
/// @param _joinAddr Join address to check
function getTokenFromJoin(address _joinAddr) internal view returns (address) {
// if it's dai_join_addr don't check gem() it will fail, return dai addr
if (_joinAddr == DAI_JOIN_ADDR) {
return DAI_ADDR;
}
return address(IJoin(_joinAddr).gem());
}
/// @notice Gets CDP info (collateral, debt)
/// @param _manager Manager contract
/// @param _cdpId Id of the CDP
/// @param _ilk Ilk of the CDP
function getCdpInfo(IManager _manager, uint _cdpId, bytes32 _ilk) public view returns (uint, uint) {
address urn = _manager.urns(_cdpId);
(uint collateral, uint debt) = vat.urns(_ilk, urn);
(,uint rate,,,) = vat.ilks(_ilk);
return (collateral, rmul(debt, rate));
}
/// @notice Address that owns the DSProxy that owns the CDP
/// @param _manager Manager contract
/// @param _cdpId Id of the CDP
function getOwner(IManager _manager, uint _cdpId) public view returns (address) {
DSProxy proxy = DSProxy(uint160(_manager.owns(_cdpId)));
return proxy.owner();
}
}
/// @title Supply collateral to a Maker vault
contract McdSupply is ActionBase, McdHelper {
using TokenUtils for address;
/// @inheritdoc ActionBase
function executeAction(
bytes[] memory _callData,
bytes[] memory _subData,
uint8[] memory _paramMapping,
bytes32[] memory _returnValues
) public payable override returns (bytes32) {
(uint256 vaultId, uint256 amount, address joinAddr, address from, address mcdManager) =
parseInputs(_callData);
vaultId = _parseParamUint(vaultId, _paramMapping[0], _subData, _returnValues);
amount = _parseParamUint(amount, _paramMapping[1], _subData, _returnValues);
joinAddr = _parseParamAddr(joinAddr, _paramMapping[2], _subData, _returnValues);
from = _parseParamAddr(from, _paramMapping[3], _subData, _returnValues);
uint256 returnAmount = _mcdSupply(vaultId, amount, joinAddr, from, mcdManager);
return bytes32(returnAmount);
}
/// @inheritdoc ActionBase
function executeActionDirect(bytes[] memory _callData) public payable override {
(uint256 vaultId, uint256 amount, address joinAddr, address from, address mcdManager) =
parseInputs(_callData);
_mcdSupply(vaultId, amount, joinAddr, from, mcdManager);
}
/// @inheritdoc ActionBase
function actionType() public pure override returns (uint8) {
return uint8(ActionType.STANDARD_ACTION);
}
//////////////////////////// ACTION LOGIC ////////////////////////////
/// @notice Supplies collateral to the vault
/// @param _vaultId Id of the vault
/// @param _amount Amount of tokens to supply
/// @param _joinAddr Join address of the maker collateral
/// @param _from Address where to pull the collateral from
/// @param _mcdManager The manager address we are using [mcd, b.protocol]
function _mcdSupply(
uint256 _vaultId,
uint256 _amount,
address _joinAddr,
address _from,
address _mcdManager
) internal returns (uint256) {
address tokenAddr = getTokenFromJoin(_joinAddr);
IManager mcdManager = IManager(_mcdManager);
// if amount type(uint).max, pull current proxy balance
if (_amount == type(uint256).max) {
_amount = tokenAddr.getBalance(address(this));
}
// Pull the underlying token and join the maker join pool
tokenAddr.pullTokensIfNeeded(_from, _amount);
tokenAddr.approveToken(_joinAddr, _amount);
IJoin(_joinAddr).join(address(this), _amount);
// format the amount we need for frob
int256 convertAmount = toPositiveInt(convertTo18(_joinAddr, _amount));
// Supply to the vault balance
vat.frob(
mcdManager.ilks(_vaultId),
mcdManager.urns(_vaultId),
address(this),
address(this),
convertAmount,
0
);
logger.Log(
address(this),
msg.sender,
"McdSupply",
abi.encode(_vaultId, _amount, _joinAddr, _from, _mcdManager)
);
return _amount;
}
function parseInputs(bytes[] memory _callData)
internal
pure
returns (
uint256 vaultId,
uint256 amount,
address joinAddr,
address from,
address mcdManager
)
{
vaultId = abi.decode(_callData[0], (uint256));
amount = abi.decode(_callData[1], (uint256));
joinAddr = abi.decode(_callData[2], (address));
from = abi.decode(_callData[3], (address));
mcdManager = abi.decode(_callData[4], (address));
}
} | format the amount we need for frob | int256 convertAmount = toPositiveInt(convertTo18(_joinAddr, _amount));
| 3,296 | [
1,
2139,
326,
3844,
732,
1608,
364,
284,
303,
70,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
509,
5034,
1765,
6275,
273,
358,
14900,
1702,
12,
6283,
774,
2643,
24899,
5701,
3178,
16,
389,
8949,
10019,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/1/0x022034A4F121C66033A7D783A577eA863eDA9Ced/sources/UtilizationFarm.sol | * @dev Collection of functions related to the address type/ | library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
return (codehash != 0x0 && codehash != accountHash);
}
assembly { codehash := extcodehash(account) }
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
require(success, "Address: unable to send value, recipient may have reverted");
}
(bool success, ) = recipient.call{value: amount}("");
}
| 4,192,433 | [
1,
2532,
434,
4186,
3746,
358,
326,
1758,
618,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
12083,
5267,
288,
203,
203,
565,
445,
353,
8924,
12,
2867,
2236,
13,
2713,
1476,
1135,
261,
6430,
13,
288,
203,
203,
3639,
1731,
1578,
981,
2816,
31,
203,
3639,
1731,
1578,
2236,
2310,
273,
374,
6511,
25,
72,
3247,
26,
1611,
5292,
74,
9060,
3707,
71,
29,
5324,
73,
27,
1966,
22,
72,
952,
27,
4630,
71,
20,
73,
12483,
70,
26,
8643,
5353,
24532,
9036,
70,
27,
17156,
361,
28,
3028,
25,
72,
7140,
69,
24,
7301,
31,
203,
3639,
327,
261,
710,
2816,
480,
374,
92,
20,
597,
981,
2816,
480,
2236,
2310,
1769,
203,
565,
289,
203,
203,
3639,
19931,
288,
981,
2816,
519,
1110,
710,
2816,
12,
4631,
13,
289,
203,
565,
445,
1366,
620,
12,
2867,
8843,
429,
8027,
16,
2254,
5034,
3844,
13,
2713,
288,
203,
3639,
2583,
12,
2867,
12,
2211,
2934,
12296,
1545,
3844,
16,
315,
1887,
30,
2763,
11339,
11013,
8863,
203,
203,
3639,
2583,
12,
4768,
16,
315,
1887,
30,
13496,
358,
1366,
460,
16,
8027,
2026,
1240,
15226,
329,
8863,
203,
565,
289,
203,
3639,
261,
6430,
2216,
16,
262,
273,
8027,
18,
1991,
95,
1132,
30,
3844,
97,
2932,
8863,
203,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// Sources flattened with hardhat v2.6.0 https://hardhat.org
// File contracts/libraries/SafeMath.sol
pragma solidity ^0.6.6;
/**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*
* @dev Default OpenZeppelin
*/
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on 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-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File contracts/general/ExpireTracker.sol
pragma solidity ^0.6.6;
/**
* @title Expire Traker
* @dev Keeps track of expired NFTs.
**/
contract ExpireTracker {
using SafeMath for uint64;
using SafeMath for uint256;
// 1 day for each step.
uint64 public constant BUCKET_STEP = 1 days;
// indicates where to start from
// points where TokenInfo with (expiredAt / BUCKET_STEP) == index
mapping(uint64 => Bucket) public checkPoints;
struct Bucket {
uint96 head;
uint96 tail;
}
// points first active nft
uint96 public head;
// points last active nft
uint96 public tail;
// maps expireId to deposit info
mapping(uint96 => ExpireMetadata) public infos;
// pack data to reduce gas
struct ExpireMetadata {
uint96 next; // zero if there is no further information
uint96 prev;
uint64 expiresAt;
}
function expired() internal view returns(bool) {
if(infos[head].expiresAt == 0) {
return false;
}
if(infos[head].expiresAt <= uint64(now)){
return true;
}
return false;
}
// using typecasted expireId to save gas
function push(uint96 expireId, uint64 expiresAt)
internal
{
require(expireId != 0, "info id 0 cannot be supported");
// If this is a replacement for a current balance, remove it's current link first.
if (infos[expireId].expiresAt > 0) pop(expireId);
uint64 bucket = uint64( (expiresAt.div(BUCKET_STEP)).mul(BUCKET_STEP) );
if (head == 0) {
// all the nfts are expired. so just add
head = expireId;
tail = expireId;
checkPoints[bucket] = Bucket(expireId, expireId);
infos[expireId] = ExpireMetadata(0,0,expiresAt);
return;
}
// there is active nft. we need to find where to push
// first check if this expires faster than head
if (infos[head].expiresAt >= expiresAt) {
// pushing nft is going to expire first
// update head
infos[head].prev = expireId;
infos[expireId] = ExpireMetadata(head,0,expiresAt);
head = expireId;
// update head of bucket
Bucket storage b = checkPoints[bucket];
b.head = expireId;
if(b.tail == 0) {
// if tail is zero, this bucket was empty should fill tail with expireId
b.tail = expireId;
}
// this case can end now
return;
}
// then check if depositing nft will last more than latest
if (infos[tail].expiresAt <= expiresAt) {
infos[tail].next = expireId;
// push nft at tail
infos[expireId] = ExpireMetadata(0,tail,expiresAt);
tail = expireId;
// update tail of bucket
Bucket storage b = checkPoints[bucket];
b.tail = expireId;
if(b.head == 0){
// if head is zero, this bucket was empty should fill head with expireId
b.head = expireId;
}
// this case is done now
return;
}
// so our nft is somewhere in between
if (checkPoints[bucket].head != 0) {
//bucket is not empty
//we just need to find our neighbor in the bucket
uint96 cursor = checkPoints[bucket].head;
// iterate until we find our nft's next
while(infos[cursor].expiresAt < expiresAt){
cursor = infos[cursor].next;
}
infos[expireId] = ExpireMetadata(cursor, infos[cursor].prev, expiresAt);
infos[infos[cursor].prev].next = expireId;
infos[cursor].prev = expireId;
//now update bucket's head/tail data
Bucket storage b = checkPoints[bucket];
if (infos[b.head].prev == expireId){
b.head = expireId;
}
if (infos[b.tail].next == expireId){
b.tail = expireId;
}
} else {
//bucket is empty
//should find which bucket has depositing nft's closest neighbor
// step 1 find prev bucket
uint64 prevCursor = bucket - BUCKET_STEP;
while(checkPoints[prevCursor].tail == 0){
prevCursor = uint64( prevCursor.sub(BUCKET_STEP) );
}
uint96 prev = checkPoints[prevCursor].tail;
uint96 next = infos[prev].next;
// step 2 link prev buckets tail - nft - next buckets head
infos[expireId] = ExpireMetadata(next,prev,expiresAt);
infos[prev].next = expireId;
infos[next].prev = expireId;
checkPoints[bucket].head = expireId;
checkPoints[bucket].tail = expireId;
}
}
function _pop(uint96 expireId, uint256 bucketStep) private {
uint64 expiresAt = infos[expireId].expiresAt;
uint64 bucket = uint64( (expiresAt.div(bucketStep)).mul(bucketStep) );
// check if bucket is empty
// if bucket is empty, end
if(checkPoints[bucket].head == 0){
return;
}
// if bucket is not empty, iterate through
// if expiresAt of current cursor is larger than expiresAt of parameter, reverts
for(uint96 cursor = checkPoints[bucket].head; infos[cursor].expiresAt <= expiresAt; cursor = infos[cursor].next) {
ExpireMetadata memory info = infos[cursor];
// if expiresAt is same of paramter, check if expireId is same
if(info.expiresAt == expiresAt && cursor == expireId) {
// if yes, delete it
// if cursor was head, move head to cursor.next
if(head == cursor) {
head = info.next;
}
// if cursor was tail, move tail to cursor.prev
if(tail == cursor) {
tail = info.prev;
}
// if cursor was head of bucket
if(checkPoints[bucket].head == cursor){
// and cursor.next is still in same bucket, move head to cursor.next
if(infos[info.next].expiresAt.div(bucketStep) == bucket.div(bucketStep)) {
checkPoints[bucket].head = info.next;
} else {
// delete whole checkpoint if bucket is now empty
delete checkPoints[bucket];
}
} else if(checkPoints[bucket].tail == cursor){
// since bucket.tail == bucket.haed == cursor case is handled at the above,
// we only have to handle bucket.tail == cursor != bucket.head
checkPoints[bucket].tail = info.prev;
}
// now we handled all tail/head situation, we have to connect prev and next
infos[info.prev].next = info.next;
infos[info.next].prev = info.prev;
// delete info and end
delete infos[cursor];
return;
}
// if not, continue -> since there can be same expires at with multiple expireId
}
//changed to return for consistency
return;
//revert("Info does not exist");
}
function pop(uint96 expireId) internal {
_pop(expireId, BUCKET_STEP);
}
function pop(uint96 expireId, uint256 step) internal {
_pop(expireId, step);
}
uint256[50] private __gap;
}
// File contracts/interfaces/IArmorMaster.sol
pragma solidity ^0.6.0;
interface IArmorMaster {
function registerModule(bytes32 _key, address _module) external;
function getModule(bytes32 _key) external view returns(address);
function keep() external;
}
// File contracts/general/Ownable.sol
pragma solidity ^0.6.6;
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*
* @dev Completely default OpenZeppelin.
*/
contract Ownable {
address private _owner;
address private _pendingOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function initializeOwnable() internal {
require(_owner == address(0), "already initialized");
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner(), "msg.sender is not owner");
_;
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
_pendingOwner = newOwner;
}
function receiveOwnership() public {
require(msg.sender == _pendingOwner, "only pending owner can call this function");
_transferOwnership(_pendingOwner);
_pendingOwner = address(0);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[50] private __gap;
}
// File contracts/general/Bytes32.sol
pragma solidity ^0.6.6;
library Bytes32 {
function toString(bytes32 x) internal pure returns (string memory) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
for (uint256 j = 0; j < 32; j++) {
byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
if (char != 0) {
bytesString[charCount] = char;
charCount++;
}
}
bytes memory bytesStringTrimmed = new bytes(charCount);
for (uint256 j = 0; j < charCount; j++) {
bytesStringTrimmed[j] = bytesString[j];
}
return string(bytesStringTrimmed);
}
}
// File contracts/general/ArmorModule.sol
pragma solidity ^0.6.0;
/**
* @dev Each arCore contract is a module to enable simple communication and interoperability. ArmorMaster.sol is master.
**/
contract ArmorModule {
IArmorMaster internal _master;
using Bytes32 for bytes32;
modifier onlyOwner() {
require(msg.sender == Ownable(address(_master)).owner(), "only owner can call this function");
_;
}
modifier doKeep() {
_master.keep();
_;
}
modifier onlyModule(bytes32 _module) {
string memory message = string(abi.encodePacked("only module ", _module.toString()," can call this function"));
require(msg.sender == getModule(_module), message);
_;
}
/**
* @dev Used when multiple can call.
**/
modifier onlyModules(bytes32 _moduleOne, bytes32 _moduleTwo) {
string memory message = string(abi.encodePacked("only module ", _moduleOne.toString()," or ", _moduleTwo.toString()," can call this function"));
require(msg.sender == getModule(_moduleOne) || msg.sender == getModule(_moduleTwo), message);
_;
}
function initializeModule(address _armorMaster) internal {
require(address(_master) == address(0), "already initialized");
require(_armorMaster != address(0), "master cannot be zero address");
_master = IArmorMaster(_armorMaster);
}
function changeMaster(address _newMaster) external onlyOwner {
_master = IArmorMaster(_newMaster);
}
function getModule(bytes32 _key) internal view returns(address) {
return _master.getModule(_key);
}
}
// File contracts/interfaces/IERC20.sol
pragma solidity ^0.6.6;
/**
* @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);
}
// File contracts/interfaces/IERC165.sol
pragma solidity ^0.6.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File contracts/interfaces/IERC721.sol
pragma solidity ^0.6.6;
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
// File contracts/interfaces/IarNFT.sol
pragma solidity ^0.6.6;
interface IarNFT is IERC721 {
function getToken(uint256 _tokenId) external returns (uint256, uint8, uint256, uint16, uint256, address, bytes4, uint256, uint256, uint256);
function submitClaim(uint256 _tokenId) external;
function redeemClaim(uint256 _tokenId) external;
}
// File contracts/interfaces/IRewardDistributionRecipient.sol
pragma solidity ^0.6.6;
interface IRewardDistributionRecipient {
function notifyRewardAmount(uint256 reward) payable external;
}
// File contracts/interfaces/IRewardManager.sol
pragma solidity ^0.6.6;
interface IRewardManager is IRewardDistributionRecipient {
function initialize(address _rewardToken, address _stakeManager) external;
function stake(address _user, uint256 _coverPrice, uint256 _nftId) external;
function withdraw(address _user, uint256 _coverPrice, uint256 _nftId) external;
function getReward(address payable _user) external;
}
// File contracts/interfaces/IRewardManagerV2.sol
pragma solidity ^0.6.6;
interface IRewardManagerV2 {
function initialize(address _armorMaster, uint256 _rewardCycleBlocks)
external;
function deposit(
address _user,
address _protocol,
uint256 _amount,
uint256 _nftId
) external;
function withdraw(
address _user,
address _protocol,
uint256 _amount,
uint256 _nftId
) external;
function updateAllocPoint(address _protocol, uint256 _allocPoint) external;
function initPool(address _protocol) external;
function notifyRewardAmount() external payable;
}
// File contracts/interfaces/IBalanceWrapper.sol
pragma solidity ^0.6.6;
interface IBalanceWrapper {
function balanceOf(address _user) external view returns (uint256);
}
// File contracts/interfaces/IPlanManager.sol
pragma solidity ^0.6.6;
interface IPlanManager {
// Mapping = protocol => cover amount
struct Plan {
uint64 startTime;
uint64 endTime;
uint128 length;
}
struct ProtocolPlan {
uint64 protocolId;
uint192 amount;
}
// Event to notify frontend of plan update.
event PlanUpdate(address indexed user, address[] protocols, uint256[] amounts, uint256 endTime);
function userCoverageLimit(address _user, address _protocol) external view returns(uint256);
function markup() external view returns(uint256);
function nftCoverPrice(address _protocol) external view returns(uint256);
function initialize(address _armorManager) external;
function changePrice(address _scAddress, uint256 _pricePerAmount) external;
function updatePlan(address[] calldata _protocols, uint256[] calldata _coverAmounts) external;
function checkCoverage(address _user, address _protocol, uint256 _hacktime, uint256 _amount) external view returns (uint256, bool);
function coverageLeft(address _protocol) external view returns(uint256);
function getCurrentPlan(address _user) external view returns(uint256 idx, uint128 start, uint128 end);
function updateExpireTime(address _user, uint256 _expiry) external;
function planRedeemed(address _user, uint256 _planIndex, address _protocol) external;
function totalUsedCover(address _scAddress) external view returns (uint256);
}
// File contracts/interfaces/IClaimManager.sol
pragma solidity ^0.6.6;
interface IClaimManager {
function initialize(address _armorMaster) external;
function transferNft(address _to, uint256 _nftId) external;
function exchangeWithdrawal(uint256 _amount) external;
function redeemClaim(address _protocol, uint256 _hackTime, uint256 _amount) external;
}
// File contracts/interfaces/IStakeManager.sol
pragma solidity ^0.6.6;
interface IStakeManager {
function totalStakedAmount(address protocol) external view returns(uint256);
function protocolAddress(uint64 id) external view returns(address);
function protocolId(address protocol) external view returns(uint64);
function initialize(address _armorMaster) external;
function allowedCover(address _newProtocol, uint256 _newTotalCover) external view returns (bool);
function subtractTotal(uint256 _nftId, address _protocol, uint256 _subtractAmount) external;
}
// File contracts/interfaces/IUtilizationFarm.sol
pragma solidity ^0.6.6;
interface IUtilizationFarm is IRewardDistributionRecipient {
function initialize(address _rewardToken, address _stakeManager) external;
function stake(address _user, uint256 _coverPrice) external;
function withdraw(address _user, uint256 _coverPrice) external;
function getReward(address payable _user) external;
}
// File contracts/core/StakeManager.sol
// SPDX-License-Identifier: (c) Armor.Fi DAO, 2021
pragma solidity ^0.6.6;
/**
* @dev Encompasses all functions taken by stakers.
**/
contract StakeManager is ArmorModule, ExpireTracker, IStakeManager {
using SafeMath for uint;
bytes4 public constant ETH_SIG = bytes4(0x45544800);
// Whether or not utilization farming is on.
bool ufOn;
// Amount of time--in seconds--a user must wait to withdraw an NFT.
uint256 withdrawalDelay;
// Protocols that staking is allowed for. We may not allow all NFTs.
mapping (address => bool) public allowedProtocol;
mapping (address => uint64) public override protocolId;
mapping (uint64 => address) public override protocolAddress;
uint64 protocolCount;
// The total amount of cover that is currently being staked. scAddress => cover amount
mapping (address => uint256) public override totalStakedAmount;
// Mapping to keep track of which NFT is owned by whom. NFT ID => owner address.
mapping (uint256 => address) public nftOwners;
// When the NFT can be withdrawn. NFT ID => Unix timestamp.
mapping (uint256 => uint256) public pendingWithdrawals;
// Track if the NFT was submitted, in which case total staked has already been lowered.
mapping (uint256 => bool) public submitted;
// Show NFT migrated status
mapping (uint256 => bool) public coverMigrated;
// Event launched when an NFT is staked.
event StakedNFT(address indexed user, address indexed protocol, uint256 nftId, uint256 sumAssured, uint256 secondPrice, uint16 coverPeriod, uint256 timestamp);
// Event launched when an NFT expires.
event RemovedNFT(address indexed user, address indexed protocol, uint256 nftId, uint256 sumAssured, uint256 secondPrice, uint16 coverPeriod, uint256 timestamp);
event ExpiredNFT(address indexed user, uint256 nftId, uint256 timestamp);
// Event launched when an NFT expires.
event WithdrawRequest(address indexed user, uint256 nftId, uint256 timestamp, uint256 withdrawTimestamp);
/**
* @dev Construct the contract with the yNft contract.
**/
function initialize(address _armorMaster)
public
override
{
initializeModule(_armorMaster);
// Let's be explicit.
withdrawalDelay = 7 days;
ufOn = true;
}
/**
* @dev Keep function can be called by anyone to remove any NFTs that have expired. Also run when calling many functions.
* This is external because the doKeep modifier calls back to ArmorMaster, which then calls back to here (and elsewhere).
**/
function keep() external {
for (uint256 i = 0; i < 2; i++) {
if (infos[head].expiresAt != 0 && infos[head].expiresAt <= now) _removeExpiredNft(head);
else return;
}
}
/**
* @dev stakeNft allows a user to submit their NFT to the contract and begin getting returns.
* This yNft cannot be withdrawn!
* @param _nftId The ID of the NFT being staked.
**/
function stakeNft(uint256 _nftId)
public
// doKeep
{
_stake(_nftId, msg.sender);
}
/**
* @dev stakeNft allows a user to submit their NFT to the contract and begin getting returns.
* @param _nftIds The ID of the NFT being staked.
**/
function batchStakeNft(uint256[] memory _nftIds)
public
// doKeep
{
// Loop through all submitted NFT IDs and stake them.
for (uint256 i = 0; i < _nftIds.length; i++) {
_stake(_nftIds[i], msg.sender);
}
}
/**
* @dev A user may call to withdraw their NFT. This may have a delay added to it.
* @param _nftId ID of the NFT to withdraw.
**/
function withdrawNft(uint256 _nftId)
external
// doKeep
{
// Check when this NFT is allowed to be withdrawn. If 0, set it.
uint256 withdrawalTime = pendingWithdrawals[_nftId];
if (withdrawalTime == 0) {
require(nftOwners[_nftId] == msg.sender, "Sender does not own this NFT.");
(/*coverId*/, uint8 coverStatus, uint256 sumAssured, /*uint16 coverPeriod*/, /*uint256 validUntil*/, address scAddress,
/*bytes4 coverCurrency*/, /*premiumNXM*/, /*uint256 coverPrice*/, /*claimId*/) = IarNFT( getModule("ARNFT") ).getToken(_nftId);
uint256 totalUsedCover = IPlanManager( getModule("PLAN") ).totalUsedCover(scAddress);
bool withdrawable = totalUsedCover <= totalStakedAmount[scAddress].sub(sumAssured * 1e18);
require(coverStatus == 0 && withdrawable, "May not withdraw NFT if it will bring staked amount below borrowed amount.");
withdrawalTime = block.timestamp + withdrawalDelay;
pendingWithdrawals[_nftId] = withdrawalTime;
_removeNft(_nftId);
emit WithdrawRequest(msg.sender, _nftId, block.timestamp, withdrawalTime);
} else if (withdrawalTime <= block.timestamp) {
(/*coverId*/, uint8 coverStatus, /*uint256 sumAssured*/, /*uint16 coverPeriod*/, /*uint256 validUntil*/, /*address scAddress*/,
/*bytes4 coverCurrency*/, /*premiumNXM*/, /*uint256 coverPrice*/, /*claimId*/) = IarNFT(getModule("ARNFT")).getToken(_nftId);
// Added after update in case someone initiated withdrawal before update, then executed after update, in which case their NFT is never removed.
if (ExpireTracker.infos[uint96(_nftId)].next > 0) _removeNft(_nftId);
require(coverStatus == 0, "May not withdraw while claim is occurring.");
address nftOwner = nftOwners[_nftId];
IClaimManager(getModule("CLAIM")).transferNft(nftOwner, _nftId);
delete pendingWithdrawals[_nftId];
delete nftOwners[_nftId];
}
}
/**
* @dev Subtract from total staked. Used by ClaimManager in case NFT is submitted.
* @param _protocol Address of the protocol to subtract from.
* @param _subtractAmount Amount of staked to subtract.
**/
function subtractTotal(uint256 _nftId, address _protocol, uint256 _subtractAmount)
external
override
onlyModule("CLAIM")
{
totalStakedAmount[_protocol] = totalStakedAmount[_protocol].sub(_subtractAmount);
submitted[_nftId] = true;
}
/**
* @dev Check whether a new TOTAL cover is allowed.
* @param _protocol Address of the smart contract protocol being protected.
* @param _totalBorrowedAmount The new total amount that would be being borrowed.
* returns Whether or not this new total borrowed amount would be able to be covered.
**/
function allowedCover(address _protocol, uint256 _totalBorrowedAmount)
external
override
view
returns (bool)
{
return _totalBorrowedAmount <= totalStakedAmount[_protocol];
}
/**
* @dev Internal function for staking--this allows us to skip updating stake multiple times during a batch stake.
* @param _nftId The ID of the NFT being staked. == coverId
* @param _user The user who is staking the NFT.
**/
function _stake(uint256 _nftId, address _user)
internal
{
(/*coverId*/, uint8 coverStatus, uint256 sumAssured, uint16 coverPeriod, uint256 validUntil, address scAddress,
bytes4 coverCurrency, /*premiumNXM*/, uint256 coverPrice, /*claimId*/) = IarNFT( getModule("ARNFT") ).getToken(_nftId);
_checkNftValid(validUntil, scAddress, coverCurrency, coverStatus);
// coverPrice must be determined by dividing by length.
uint256 secondPrice = coverPrice / (uint256(coverPeriod) * 1 days);
// Update PlanManager to use the correct price for the protocol.
// Find price per amount here to update plan manager correctly.
uint256 pricePerEth = secondPrice / sumAssured;
IPlanManager(getModule("PLAN")).changePrice(scAddress, pricePerEth);
IarNFT(getModule("ARNFT")).transferFrom(_user, getModule("CLAIM"), _nftId);
ExpireTracker.push(uint96(_nftId), uint64(validUntil));
// Save owner of NFT.
nftOwners[_nftId] = _user;
uint256 weiSumAssured = sumAssured * (10 ** 18);
_addCovers(_user, _nftId, weiSumAssured, secondPrice, scAddress);
// Add to utilization farming.
if (ufOn) IUtilizationFarm(getModule("UFS")).stake(_user, secondPrice);
emit StakedNFT(_user, scAddress, _nftId, weiSumAssured, secondPrice, coverPeriod, block.timestamp);
}
/**
* @dev removeExpiredNft is called on many different interactions to the system overall.
* @param _nftId The ID of the expired NFT.
**/
function _removeExpiredNft(uint256 _nftId)
internal
{
address user = nftOwners[_nftId];
_removeNft(_nftId);
delete nftOwners[_nftId];
emit ExpiredNFT(user, _nftId, block.timestamp);
}
/**
* @dev Internal main removal functionality.
**/
function _removeNft(uint256 _nftId)
internal
{
(/*coverId*/, /*status*/, uint256 sumAssured, uint16 coverPeriod, /*uint256 validuntil*/, address scAddress,
/*coverCurrency*/, /*premiumNXM*/, uint256 coverPrice, /*claimId*/) = IarNFT(getModule("ARNFT")).getToken(_nftId);
address user = nftOwners[_nftId];
require(user != address(0), "NFT does not belong to this contract.");
ExpireTracker.pop(uint96(_nftId));
uint256 weiSumAssured = sumAssured * (10 ** 18);
uint256 secondPrice = coverPrice / (uint256(coverPeriod) * 1 days);
_subtractCovers(user, _nftId, weiSumAssured, secondPrice, scAddress);
// Exit from utilization farming.
if (ufOn) IUtilizationFarm(getModule("UFS")).withdraw(user, secondPrice);
emit RemovedNFT(user, scAddress, _nftId, weiSumAssured, secondPrice, coverPeriod, block.timestamp);
}
/**
* @dev Need a force remove--at least temporarily--where owner can remove data relating to an NFT.
* This necessity came about when updating the contracts and some users started withdrawal when _removeNFT
* was in the second step of withdrawal, then executed the second step of withdrawal after _removeNFT had
* been moved to the first step of withdrawal.
**/
function forceRemoveNft(address[] calldata _users, uint256[] calldata _nftIds)
external
onlyOwner
{
require(_users.length == _nftIds.length, "Array lengths must match.");
for (uint256 i = 0; i < _users.length; i++) {
uint256 nftId = _nftIds[i];
address user = _users[i];
(/*coverId*/, /*status*/, uint256 sumAssured, uint16 coverPeriod, /*uint256 validuntil*/, address scAddress,
/*coverCurrency*/, /*premiumNXM*/, uint256 coverPrice, /*claimId*/) = IarNFT(getModule("ARNFT")).getToken(nftId);
//address user = nftOwners[_nftId];
// require(user != address(0), "NFT does not belong to this contract.");
require(nftOwners[nftId] == address(0) && ExpireTracker.infos[uint96(nftId)].next > 0, "NFT may not be force removed.");
ExpireTracker.pop(uint96(nftId));
uint256 weiSumAssured = sumAssured * (10 ** 18);
uint256 secondPrice = coverPrice / (uint256(coverPeriod) * 1 days);
_subtractCovers(user, nftId, weiSumAssured, secondPrice, scAddress);
// Exit from utilization farming.
if (ufOn) IUtilizationFarm(getModule("UFS")).withdraw(user, secondPrice);
emit RemovedNFT(user, scAddress, nftId, weiSumAssured, secondPrice, coverPeriod, block.timestamp);
}
}
/**
* @dev Some NFT expiries used a different bucket step upon update and must be reset.
**/
function forceResetExpires(uint256[] calldata _nftIds)
external
onlyOwner
{
uint64[] memory validUntils = new uint64[](_nftIds.length);
for (uint256 i = 0; i < _nftIds.length; i++) {
(/*coverId*/, /*status*/, /*uint256 sumAssured*/, /*uint16 coverPeriod*/, uint256 validUntil, /*address scAddress*/,
/*coverCurrency*/, /*premiumNXM*/, /*uint256 coverPrice*/, /*claimId*/) = IarNFT(getModule("ARNFT")).getToken(_nftIds[i]);
require(nftOwners[_nftIds[i]] != address(0), "this nft does not belong here");
ExpireTracker.pop(uint96(_nftIds[i]), 86400);
ExpireTracker.pop(uint96(_nftIds[i]), 86400*3);
validUntils[i] = uint64(validUntil);
}
for (uint256 i = 0; i < _nftIds.length; i++) {
ExpireTracker.push(uint96(_nftIds[i]),uint64(validUntils[i]));
}
}
// set desired head and tail
function _resetBucket(uint64 _bucket, uint96 _head, uint96 _tail) internal {
require(_bucket % BUCKET_STEP == 0, "INVALID BUCKET");
checkPoints[_bucket].tail = _tail;
checkPoints[_bucket].head = _head;
}
function resetBuckets(uint64[] calldata _buckets, uint96[] calldata _heads, uint96[] calldata _tails) external onlyOwner{
for(uint256 i = 0 ; i< _buckets.length; i++){
_resetBucket(_buckets[i], _heads[i], _tails[i]);
}
}
/**
* @dev Add to the cover amount for the user and contract overall.
* @param _user The user who submitted.
* @param _nftId ID of the NFT being staked (used for events on RewardManager).
* @param _coverAmount The amount of cover being added.
* @param _coverPrice Price paid by the user for the NFT per second.
* @param _protocol Address of the protocol that is having cover added.
**/
function _addCovers(address _user, uint256 _nftId, uint256 _coverAmount, uint256 _coverPrice, address _protocol)
internal
{
IRewardManagerV2(getModule("REWARDV2")).deposit(_user, _protocol, _coverPrice, _nftId);
totalStakedAmount[_protocol] = totalStakedAmount[_protocol].add(_coverAmount);
coverMigrated[_nftId] = true;
}
/**
* @dev Subtract from the cover amount for the user and contract overall.
* @param _user The user who is having the token removed.
* @param _nftId ID of the NFT being used--must check if it has been submitted.
* @param _coverAmount The amount of cover being removed.
* @param _coverPrice Price that the user was paying per second.
* @param _protocol The protocol that this NFT protected.
**/
function _subtractCovers(address _user, uint256 _nftId, uint256 _coverAmount, uint256 _coverPrice, address _protocol)
internal
{
if (coverMigrated[_nftId]) {
IRewardManagerV2(getModule("REWARDV2")).withdraw(_user, _protocol, _coverPrice, _nftId);
} else {
IRewardManager(getModule("REWARD")).withdraw(_user, _coverPrice, _nftId);
}
if (!submitted[_nftId]) totalStakedAmount[_protocol] = totalStakedAmount[_protocol].sub(_coverAmount);
}
/**
* @dev Migrate reward to V2
* @param _nftIds Nft ids
**/
function migrateCovers(uint256[] calldata _nftIds)
external
{
for (uint256 i = 0; i < _nftIds.length; i += 1) {
address user = nftOwners[_nftIds[i]];
require(user != address(0), "NFT not staked.");
require(coverMigrated[_nftIds[i]] == false, "Already migrated.");
coverMigrated[_nftIds[i]] = true;
(/*coverId*/, /*status*/, /*sumAssured*/, uint16 coverPeriod, /*uint256 validuntil*/, address scAddress,
/*coverCurrency*/, /*premiumNXM*/, uint256 coverPrice, /*claimId*/) = IarNFT(getModule("ARNFT")).getToken(_nftIds[i]);
uint256 secondPrice = coverPrice / (uint256(coverPeriod) * 1 days);
IRewardManager(getModule("REWARD")).withdraw(user, secondPrice, _nftIds[i]);
IRewardManagerV2(getModule("REWARDV2")).deposit(user, scAddress, secondPrice, _nftIds[i]);
}
}
/**
* @dev Check that the NFT should be allowed to be added. We check expiry and claimInProgress.
* @param _validUntil The expiration time of this NFT.
* @param _scAddress The smart contract protocol that the NFt is protecting.
* @param _coverCurrency The currency that this NFT is protected in (must be ETH_SIG).
* @param _coverStatus status of cover, only accepts Active
**/
function _checkNftValid(uint256 _validUntil, address _scAddress, bytes4 _coverCurrency, uint8 _coverStatus)
internal
view
{
require(_validUntil > now + 20 days, "NFT is expired or within 20 days of expiry.");
require(_coverStatus == 0, "arNFT claim is already in progress.");
require(allowedProtocol[_scAddress], "Protocol is not allowed to be staked.");
require(_coverCurrency == ETH_SIG, "Only Ether arNFTs may be staked.");
}
/**
* @dev Allow the owner (DAO soon) to allow or disallow a protocol from being used in Armor.
* @param _protocol The address of the protocol to allow or disallow.
* @param _allow Whether to allow or disallow the protocol.
**/
function allowProtocol(address _protocol, bool _allow)
external
// doKeep
onlyOwner
{
if(protocolId[_protocol] == 0){
protocolId[_protocol] = ++protocolCount;
protocolAddress[protocolCount] = _protocol;
}
allowedProtocol[_protocol] = _allow;
}
/**
* @dev Allow the owner to change the amount of delay to withdraw an NFT.
* @param _withdrawalDelay The amount of time--in seconds--to delay an NFT withdrawal.
**/
function changeWithdrawalDelay(uint256 _withdrawalDelay)
external
// doKeep
onlyOwner
{
withdrawalDelay = _withdrawalDelay;
}
/**
* @dev Toggle whether utilization farming should be on or off.
**/
function toggleUF()
external
onlyOwner
{
ufOn = !ufOn;
}
} | * @dev Check whether a new TOTAL cover is allowed. @param _protocol Address of the smart contract protocol being protected. @param _totalBorrowedAmount The new total amount that would be being borrowed. returns Whether or not this new total borrowed amount would be able to be covered./ | function allowedCover(address _protocol, uint256 _totalBorrowedAmount)
external
override
view
returns (bool)
{
return _totalBorrowedAmount <= totalStakedAmount[_protocol];
}
| 226,695 | [
1,
1564,
2856,
279,
394,
399,
19851,
5590,
353,
2935,
18,
225,
389,
8373,
5267,
434,
326,
13706,
6835,
1771,
3832,
4750,
18,
225,
389,
4963,
38,
15318,
329,
6275,
1021,
394,
2078,
3844,
716,
4102,
506,
3832,
29759,
329,
18,
1135,
17403,
578,
486,
333,
394,
2078,
29759,
329,
3844,
4102,
506,
7752,
358,
506,
18147,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
2935,
8084,
12,
2867,
389,
8373,
16,
2254,
5034,
389,
4963,
38,
15318,
329,
6275,
13,
203,
1377,
3903,
203,
1377,
3849,
203,
1377,
1476,
203,
565,
1135,
261,
6430,
13,
203,
565,
288,
203,
3639,
327,
389,
4963,
38,
15318,
329,
6275,
1648,
2078,
510,
9477,
6275,
63,
67,
8373,
15533,
203,
565,
289,
203,
377,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
//Address: 0xa0388ffb2a3c198dee723135e0caa423840b375a
//Contract name: Campaign
//Balance: 0 Ether
//Verification Date: 11/8/2016
//Transacion Count: 5
// CODE STARTS HERE
pragma solidity ^0.4.4;
// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/issues/20
contract Token {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract since public getter functions are not
currently recognised as an implementation of the matching abstract
function by the compiler.
*/
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
//File: /Users/jbaylina/git/MVP/StandardToken.sol
pragma solidity ^0.4.4;
/*
You should inherit from StandardToken or, for a token like you would want to
deploy in something like Mist, see HumanStandardToken.sol.
(This implements ONLY the standard functions and NOTHING else.
If you deploy this, you won't have anything useful.)
Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
.*/
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//If your token leaves out totalSupply and can issue more tokens as time
//goes on, you need to check if it doesn't wrap.
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
//if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
//File: /Users/jbaylina/git/MVP/HumanStandardToken.sol
pragma solidity ^0.4.4;
/*
This Token Contract implements the standard token functionality
(https://github.com/ethereum/EIPs/issues/20) as well as the following OPTIONAL
extras intended for use by humans.
In other words. This is intended for deployment in something like a Token
Factory or Mist wallet, and then used by humans.
Imagine coins, currencies, shares, voting weight, etc.
Machine-based, rapid creation of many tokens would not necessarily need these
extra features or will be minted in other manners.
1) Initial Finite Supply (upon creation one specifies how much is minted).
2) In the absence of a token registry: Optional Decimal, Symbol & Name.
3) Optional approveAndCall() functionality to notify a contract if an approval()
has occurred.
*/
contract HumanStandardToken is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include
them.
They allow one to customise the token contract & in no way influences the
core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show.
string public symbol; //An identifier: eg SBX
string public version = 'H0.1'; //An arbitrary versioning scheme.
function HumanStandardToken(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) {
balances[msg.sender] = _initialAmount; // Give the creator all initial tokens
totalSupply = _initialAmount; // Update total supply
name = _tokenName; // Set the name for display purposes
decimals = _decimalUnits; // Amount of decimals for display purposes
symbol = _tokenSymbol; // Set the symbol for display purposes
}
/*
/ * Approves and then calls the receiving contract * /
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be
//notified. This crafts the function signature manually so one doesn't
//have to include a contract in here just for this.
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
//it is assumed that when does this that the call *should* succeed,
//otherwise one would use vanilla approve instead.
if(!_spender.call(
bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))),
msg.sender,
_value,
this,
_extraData)) { throw; }
return true;
}
*/
}
//File: /Users/jbaylina/git/MVP/CampaignToken.sol
pragma solidity ^0.4.4;
/// @title CampaignToken Contract
/// @author Jordi Baylina
/// @dev This token contract is a clone of ConsenSys's HumanStandardToken with
/// the approveAndCall function omitted; it is ERC 20 compliant.
contract CampaignToken is HumanStandardToken {
/// @dev The tokenController is the address that deployed the CampaignToken, for this
/// token it will be it will be the Campaign Contract
address public tokenController;
/// @dev The onlyController modifier only allows the tokenController to call the function
modifier onlyController { if (msg.sender != tokenController) throw; _; }
/// @notice `CampaignToken()` is the function that deploys a new
/// HumanStandardToken with the parameters of 0 initial tokens, the name
/// "CharityDAO Token" the decimal place of the smallest unit being 18, and the
/// call sign being "GIVE". It will set the tokenController to be the contract that
/// calls the function.
function CampaignToken() HumanStandardToken(0,"CharityDAO Token",18,"GIVE") {
tokenController = msg.sender;
}
/// @notice `createTokens()` will create tokens if the campaign has not been
/// sealed.
/// @dev `createTokens()` is called by the campaign contract when
/// someone sends ether to that contract or calls `doPayment()`
/// @param beneficiary The address receiving the tokens
/// @param amount The amount of tokens the address is receiving
/// @return True if tokens are created
function createTokens(address beneficiary, uint amount
) onlyController returns (bool success) {
if (sealed()) throw;
balances[beneficiary] += amount; // Create tokens for the beneficiary
totalSupply += amount; // Update total supply
Transfer(0, beneficiary, amount); // Create an Event for the creation
return true;
}
/// @notice `seal()` ends the Campaign by making it impossible to create more
/// tokens.
/// @dev `seal()` changes the tokenController to 0 and therefore can only be called by
/// the tokenCreator contract once
/// @return True if the Campaign is sealed
function seal() onlyController returns (bool success) {
tokenController = 0;
return true;
}
/// @notice `sealed()` checks to see if the the Campaign has been sealed
/// @return True if the Campaign has been sealed and can't receive funds
function sealed() constant returns (bool) {
return tokenController == 0;
}
}
//File: /Users/jbaylina/git/MVP/Campaign.sol
pragma solidity ^0.4.4;
/// @title CampaignToken Contract
/// @author Jordi Baylina
/// @dev This is designed to control the ChairtyToken contract.
contract Campaign {
uint public startFundingTime; // In UNIX Time Format
uint public endFundingTime; // In UNIX Time Format
uint public maximumFunding; // In wei
uint public totalCollected; // In wei
CampaignToken public tokenContract; // The new token for this Campaign
address public vaultContract; // The address to hold the funds donated
/// @notice 'Campaign()' initiates the Campaign by setting its funding
/// parameters and creating the deploying the token contract
/// @dev There are several checks to make sure the parameters are acceptable
/// @param _startFundingTime The UNIX time that the Campaign will be able to
/// start receiving funds
/// @param _endFundingTime The UNIX time that the Campaign will stop being able
/// to receive funds
/// @param _maximumFunding In wei, the Maximum amount that the Campaign can
/// receive (currently the max is set at 10,000 ETH for the beta)
/// @param _vaultContract The address that will store the donated funds
function Campaign(
uint _startFundingTime,
uint _endFundingTime,
uint _maximumFunding,
address _vaultContract
) {
if ((_endFundingTime < now) || // Cannot start in the past
(_endFundingTime <= _startFundingTime) ||
(_maximumFunding > 10000 ether) || // The Beta is limited
(_vaultContract == 0)) // To prevent burning ETH
{
throw;
}
startFundingTime = _startFundingTime;
endFundingTime = _endFundingTime;
maximumFunding = _maximumFunding;
tokenContract = new CampaignToken (); // Deploys the Token Contract
vaultContract = _vaultContract;
}
/// @dev The fallback function is called when ether is sent to the contract, it
/// simply calls `doPayment()` with the address that sent the ether as the
/// `_owner`. Payable is a required solidity modifier for functions to receive
/// ether, without this modifier they will throw
function () payable {
doPayment(msg.sender);
}
/// @notice `proxyPayment()` allows the caller to send ether to the Campaign and
/// have the CampaignTokens created in an address of their choosing
/// @param _owner The address that will hold the newly created CampaignTokens
function proxyPayment(address _owner) payable {
doPayment(_owner);
}
/// @dev `doPayment()` is an internal function that sends the ether that this
/// contract receives to the `vaultContract` and creates campaignTokens in the
/// address of the `_owner` assuming the Campaign is still accepting funds
/// @param _owner The address that will hold the newly created CampaignTokens
function doPayment(address _owner) internal {
// First we check that the Campaign is allowed to receive this donation
if ((now<startFundingTime) ||
(now>endFundingTime) ||
(tokenContract.tokenController() == 0) || // Extra check
(msg.value == 0) ||
(totalCollected + msg.value > maximumFunding))
{
throw;
}
//Track how much the Campaign has collected
totalCollected += msg.value;
//Send the ether to the vaultContract
if (!vaultContract.send(msg.value)) {
throw;
}
// Creates an equal amount of CampaignTokens as ether sent. The new CampaignTokens
// are created in the `_owner` address
if (!tokenContract.createTokens(_owner, msg.value)) {
throw;
}
return;
}
/// @notice `seal()` ends the Campaign by calling `seal()` in the CampaignToken
/// contract
/// @dev `seal()` can only be called after the end of the funding period.
function seal() {
if (now < endFundingTime) throw;
tokenContract.seal();
}
}
| Update total supply
| totalSupply += amount; | 12,993,543 | [
1,
1891,
2078,
14467,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
2078,
3088,
1283,
1011,
3844,
31,
2398,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
pragma experimental ABIEncoderV2;
interface IAsset {
}
interface IVault{
function joinPool(
bytes32 poolId,
address sender,
address recipient,
JoinPoolRequest memory request
) external payable;
struct JoinPoolRequest {
IAsset[] assets;
uint256[] maxAmountsIn;
bytes userData;
bool fromInternalBalance;
}
function exitPool(
bytes32 poolId,
address sender,
address payable recipient,
ExitPoolRequest memory request
) external;
struct ExitPoolRequest {
IAsset[] assets;
uint256[] minAmountsOut;
bytes userData;
bool toInternalBalance;
}
function getPoolTokens(bytes32 poolId)
external
view
returns (
address[] memory tokens,
uint256[] memory balances,
uint256 lastChangeBlock
);
}
contract MainnetBalancerV2Addresses {
address internal constant VAULT_ADDR = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
address internal constant MERKLE_REEDEM_ADDR = 0x6d19b2bF3A36A61530909Ae65445a906D98A2Fa8;
address internal constant balToken = 0xba100000625a3754423978a60c9317c58a424e3D;
}
contract BalancerV2Helper is MainnetBalancerV2Addresses{
IVault public constant vault = IVault(VAULT_ADDR);
string public constant ADDR_MUST_NOT_BE_ZERO = "Address to which tokens will be sent to can't be burn address";
function _getPoolAddress(bytes32 poolId) internal pure returns (address) {
// 12 byte logical shift left to remove the nonce and specialization setting. We don't need to mask,
// since the logical shift already sets the upper bits to zero.
return address(uint256(poolId) >> (12 * 8));
}
}
abstract contract IDFSRegistry {
function getAddr(bytes32 _id) public view virtual returns (address);
function addNewContract(
bytes32 _id,
address _contractAddr,
uint256 _waitPeriod
) public virtual;
function startContractChange(bytes32 _id, address _newContractAddr) public virtual;
function approveContractChange(bytes32 _id) public virtual;
function cancelContractChange(bytes32 _id) public virtual;
function changeWaitPeriod(bytes32 _id, uint256 _newWaitPeriod) public virtual;
}
interface IERC20 {
function totalSupply() external view returns (uint256 supply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(
address _from,
address _to,
uint256 _value
) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
function decimals() external view returns (uint256 digits);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return
functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(
token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
);
}
/// @dev Edited so it always first approves 0 and then the value, because of non standard tokens
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(
token,
abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
);
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(
value,
"SafeERC20: decreased allowance below zero"
);
_callOptionalReturn(
token,
abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
);
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(
data,
"SafeERC20: low-level call failed"
);
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract MainnetAuthAddresses {
address internal constant ADMIN_VAULT_ADDR = 0xCCf3d848e08b94478Ed8f46fFead3008faF581fD;
address internal constant FACTORY_ADDRESS = 0x5a15566417e6C1c9546523066500bDDBc53F88C7;
address internal constant ADMIN_ADDR = 0x25eFA336886C74eA8E282ac466BdCd0199f85BB9; // USED IN ADMIN VAULT CONSTRUCTOR
}
contract AuthHelper is MainnetAuthAddresses {
}
contract AdminVault is AuthHelper {
address public owner;
address public admin;
constructor() {
owner = msg.sender;
admin = ADMIN_ADDR;
}
/// @notice Admin is able to change owner
/// @param _owner Address of new owner
function changeOwner(address _owner) public {
require(admin == msg.sender, "msg.sender not admin");
owner = _owner;
}
/// @notice Admin is able to set new admin
/// @param _admin Address of multisig that becomes new admin
function changeAdmin(address _admin) public {
require(admin == msg.sender, "msg.sender not admin");
admin = _admin;
}
}
contract AdminAuth is AuthHelper {
using SafeERC20 for IERC20;
AdminVault public constant adminVault = AdminVault(ADMIN_VAULT_ADDR);
modifier onlyOwner() {
require(adminVault.owner() == msg.sender, "msg.sender not owner");
_;
}
modifier onlyAdmin() {
require(adminVault.admin() == msg.sender, "msg.sender not admin");
_;
}
/// @notice withdraw stuck funds
function withdrawStuckFunds(address _token, address _receiver, uint256 _amount) public onlyOwner {
if (_token == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
payable(_receiver).transfer(_amount);
} else {
IERC20(_token).safeTransfer(_receiver, _amount);
}
}
/// @notice Destroy the contract
function kill() public onlyAdmin {
selfdestruct(payable(msg.sender));
}
}
contract DefisaverLogger {
event LogEvent(
address indexed contractAddress,
address indexed caller,
string indexed logName,
bytes data
);
// solhint-disable-next-line func-name-mixedcase
function Log(
address _contract,
address _caller,
string memory _logName,
bytes memory _data
) public {
emit LogEvent(_contract, _caller, _logName, _data);
}
}
contract MainnetCoreAddresses {
address internal constant DEFI_SAVER_LOGGER_ADDR = 0x5c55B921f590a89C1Ebe84dF170E655a82b62126;
address internal constant REGISTRY_ADDR = 0xD6049E1F5F3EfF1F921f5532aF1A1632bA23929C;
address internal constant PROXY_AUTH_ADDR = 0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF;
}
contract CoreHelper is MainnetCoreAddresses {
}
contract DFSRegistry is AdminAuth, CoreHelper {
DefisaverLogger public constant logger = DefisaverLogger(
DEFI_SAVER_LOGGER_ADDR
);
string public constant ERR_ENTRY_ALREADY_EXISTS = "Entry id already exists";
string public constant ERR_ENTRY_NON_EXISTENT = "Entry id doesn't exists";
string public constant ERR_ENTRY_NOT_IN_CHANGE = "Entry not in change process";
string public constant ERR_WAIT_PERIOD_SHORTER = "New wait period must be bigger";
string public constant ERR_CHANGE_NOT_READY = "Change not ready yet";
string public constant ERR_EMPTY_PREV_ADDR = "Previous addr is 0";
string public constant ERR_ALREADY_IN_CONTRACT_CHANGE = "Already in contract change";
string public constant ERR_ALREADY_IN_WAIT_PERIOD_CHANGE = "Already in wait period change";
struct Entry {
address contractAddr;
uint256 waitPeriod;
uint256 changeStartTime;
bool inContractChange;
bool inWaitPeriodChange;
bool exists;
}
mapping(bytes32 => Entry) public entries;
mapping(bytes32 => address) public previousAddresses;
mapping(bytes32 => address) public pendingAddresses;
mapping(bytes32 => uint256) public pendingWaitTimes;
/// @notice Given an contract id returns the registered address
/// @dev Id is keccak256 of the contract name
/// @param _id Id of contract
function getAddr(bytes32 _id) public view returns (address) {
return entries[_id].contractAddr;
}
/// @notice Helper function to easily query if id is registered
/// @param _id Id of contract
function isRegistered(bytes32 _id) public view returns (bool) {
return entries[_id].exists;
}
/////////////////////////// OWNER ONLY FUNCTIONS ///////////////////////////
/// @notice Adds a new contract to the registry
/// @param _id Id of contract
/// @param _contractAddr Address of the contract
/// @param _waitPeriod Amount of time to wait before a contract address can be changed
function addNewContract(
bytes32 _id,
address _contractAddr,
uint256 _waitPeriod
) public onlyOwner {
require(!entries[_id].exists, ERR_ENTRY_ALREADY_EXISTS);
entries[_id] = Entry({
contractAddr: _contractAddr,
waitPeriod: _waitPeriod,
changeStartTime: 0,
inContractChange: false,
inWaitPeriodChange: false,
exists: true
});
// Remember tha address so we can revert back to old addr if needed
previousAddresses[_id] = _contractAddr;
logger.Log(
address(this),
msg.sender,
"AddNewContract",
abi.encode(_id, _contractAddr, _waitPeriod)
);
}
/// @notice Reverts to the previous address immediately
/// @dev In case the new version has a fault, a quick way to fallback to the old contract
/// @param _id Id of contract
function revertToPreviousAddress(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(previousAddresses[_id] != address(0), ERR_EMPTY_PREV_ADDR);
address currentAddr = entries[_id].contractAddr;
entries[_id].contractAddr = previousAddresses[_id];
logger.Log(
address(this),
msg.sender,
"RevertToPreviousAddress",
abi.encode(_id, currentAddr, previousAddresses[_id])
);
}
/// @notice Starts an address change for an existing entry
/// @dev Can override a change that is currently in progress
/// @param _id Id of contract
/// @param _newContractAddr Address of the new contract
function startContractChange(bytes32 _id, address _newContractAddr) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(!entries[_id].inWaitPeriodChange, ERR_ALREADY_IN_WAIT_PERIOD_CHANGE);
entries[_id].changeStartTime = block.timestamp; // solhint-disable-line
entries[_id].inContractChange = true;
pendingAddresses[_id] = _newContractAddr;
logger.Log(
address(this),
msg.sender,
"StartContractChange",
abi.encode(_id, entries[_id].contractAddr, _newContractAddr)
);
}
/// @notice Changes new contract address, correct time must have passed
/// @param _id Id of contract
function approveContractChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inContractChange, ERR_ENTRY_NOT_IN_CHANGE);
require(
block.timestamp >= (entries[_id].changeStartTime + entries[_id].waitPeriod), // solhint-disable-line
ERR_CHANGE_NOT_READY
);
address oldContractAddr = entries[_id].contractAddr;
entries[_id].contractAddr = pendingAddresses[_id];
entries[_id].inContractChange = false;
entries[_id].changeStartTime = 0;
pendingAddresses[_id] = address(0);
previousAddresses[_id] = oldContractAddr;
logger.Log(
address(this),
msg.sender,
"ApproveContractChange",
abi.encode(_id, oldContractAddr, entries[_id].contractAddr)
);
}
/// @notice Cancel pending change
/// @param _id Id of contract
function cancelContractChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inContractChange, ERR_ENTRY_NOT_IN_CHANGE);
address oldContractAddr = pendingAddresses[_id];
pendingAddresses[_id] = address(0);
entries[_id].inContractChange = false;
entries[_id].changeStartTime = 0;
logger.Log(
address(this),
msg.sender,
"CancelContractChange",
abi.encode(_id, oldContractAddr, entries[_id].contractAddr)
);
}
/// @notice Starts the change for waitPeriod
/// @param _id Id of contract
/// @param _newWaitPeriod New wait time
function startWaitPeriodChange(bytes32 _id, uint256 _newWaitPeriod) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(!entries[_id].inContractChange, ERR_ALREADY_IN_CONTRACT_CHANGE);
pendingWaitTimes[_id] = _newWaitPeriod;
entries[_id].changeStartTime = block.timestamp; // solhint-disable-line
entries[_id].inWaitPeriodChange = true;
logger.Log(
address(this),
msg.sender,
"StartWaitPeriodChange",
abi.encode(_id, _newWaitPeriod)
);
}
/// @notice Changes new wait period, correct time must have passed
/// @param _id Id of contract
function approveWaitPeriodChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inWaitPeriodChange, ERR_ENTRY_NOT_IN_CHANGE);
require(
block.timestamp >= (entries[_id].changeStartTime + entries[_id].waitPeriod), // solhint-disable-line
ERR_CHANGE_NOT_READY
);
uint256 oldWaitTime = entries[_id].waitPeriod;
entries[_id].waitPeriod = pendingWaitTimes[_id];
entries[_id].inWaitPeriodChange = false;
entries[_id].changeStartTime = 0;
pendingWaitTimes[_id] = 0;
logger.Log(
address(this),
msg.sender,
"ApproveWaitPeriodChange",
abi.encode(_id, oldWaitTime, entries[_id].waitPeriod)
);
}
/// @notice Cancel wait period change
/// @param _id Id of contract
function cancelWaitPeriodChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inWaitPeriodChange, ERR_ENTRY_NOT_IN_CHANGE);
uint256 oldWaitPeriod = pendingWaitTimes[_id];
pendingWaitTimes[_id] = 0;
entries[_id].inWaitPeriodChange = false;
entries[_id].changeStartTime = 0;
logger.Log(
address(this),
msg.sender,
"CancelWaitPeriodChange",
abi.encode(_id, oldWaitPeriod, entries[_id].waitPeriod)
);
}
}
contract MainnetActionsUtilAddresses {
address internal constant DFS_REG_CONTROLLER_ADDR = 0xF8f8B3C98Cf2E63Df3041b73f80F362a4cf3A576;
address internal constant REGISTRY_ADDR = 0xD6049E1F5F3EfF1F921f5532aF1A1632bA23929C;
address internal constant DFS_LOGGER_ADDR = 0x5c55B921f590a89C1Ebe84dF170E655a82b62126;
}
contract ActionsUtilHelper is MainnetActionsUtilAddresses {
}
abstract contract ActionBase is AdminAuth, ActionsUtilHelper {
DFSRegistry public constant registry = DFSRegistry(REGISTRY_ADDR);
DefisaverLogger public constant logger = DefisaverLogger(
DFS_LOGGER_ADDR
);
string public constant ERR_SUB_INDEX_VALUE = "Wrong sub index value";
string public constant ERR_RETURN_INDEX_VALUE = "Wrong return index value";
/// @dev Subscription params index range [128, 255]
uint8 public constant SUB_MIN_INDEX_VALUE = 128;
uint8 public constant SUB_MAX_INDEX_VALUE = 255;
/// @dev Return params index range [1, 127]
uint8 public constant RETURN_MIN_INDEX_VALUE = 1;
uint8 public constant RETURN_MAX_INDEX_VALUE = 127;
/// @dev If the input value should not be replaced
uint8 public constant NO_PARAM_MAPPING = 0;
/// @dev We need to parse Flash loan actions in a different way
enum ActionType { FL_ACTION, STANDARD_ACTION, CUSTOM_ACTION }
/// @notice Parses inputs and runs the implemented action through a proxy
/// @dev Is called by the TaskExecutor chaining actions together
/// @param _callData Array of input values each value encoded as bytes
/// @param _subData Array of subscribed vales, replaces input values if specified
/// @param _paramMapping Array that specifies how return and subscribed values are mapped in input
/// @param _returnValues Returns values from actions before, which can be injected in inputs
/// @return Returns a bytes32 value through DSProxy, each actions implements what that value is
function executeAction(
bytes[] memory _callData,
bytes[] memory _subData,
uint8[] memory _paramMapping,
bytes32[] memory _returnValues
) public payable virtual returns (bytes32);
/// @notice Parses inputs and runs the single implemented action through a proxy
/// @dev Used to save gas when executing a single action directly
function executeActionDirect(bytes[] memory _callData) public virtual payable;
/// @notice Returns the type of action we are implementing
function actionType() public pure virtual returns (uint8);
//////////////////////////// HELPER METHODS ////////////////////////////
/// @notice Given an uint256 input, injects return/sub values if specified
/// @param _param The original input value
/// @param _mapType Indicated the type of the input in paramMapping
/// @param _subData Array of subscription data we can replace the input value with
/// @param _returnValues Array of subscription data we can replace the input value with
function _parseParamUint(
uint _param,
uint8 _mapType,
bytes[] memory _subData,
bytes32[] memory _returnValues
) internal pure returns (uint) {
if (isReplaceable(_mapType)) {
if (isReturnInjection(_mapType)) {
_param = uint(_returnValues[getReturnIndex(_mapType)]);
} else {
_param = abi.decode(_subData[getSubIndex(_mapType)], (uint));
}
}
return _param;
}
/// @notice Given an addr input, injects return/sub values if specified
/// @param _param The original input value
/// @param _mapType Indicated the type of the input in paramMapping
/// @param _subData Array of subscription data we can replace the input value with
/// @param _returnValues Array of subscription data we can replace the input value with
function _parseParamAddr(
address _param,
uint8 _mapType,
bytes[] memory _subData,
bytes32[] memory _returnValues
) internal pure returns (address) {
if (isReplaceable(_mapType)) {
if (isReturnInjection(_mapType)) {
_param = address(bytes20((_returnValues[getReturnIndex(_mapType)])));
} else {
_param = abi.decode(_subData[getSubIndex(_mapType)], (address));
}
}
return _param;
}
/// @notice Given an bytes32 input, injects return/sub values if specified
/// @param _param The original input value
/// @param _mapType Indicated the type of the input in paramMapping
/// @param _subData Array of subscription data we can replace the input value with
/// @param _returnValues Array of subscription data we can replace the input value with
function _parseParamABytes32(
bytes32 _param,
uint8 _mapType,
bytes[] memory _subData,
bytes32[] memory _returnValues
) internal pure returns (bytes32) {
if (isReplaceable(_mapType)) {
if (isReturnInjection(_mapType)) {
_param = (_returnValues[getReturnIndex(_mapType)]);
} else {
_param = abi.decode(_subData[getSubIndex(_mapType)], (bytes32));
}
}
return _param;
}
/// @notice Checks if the paramMapping value indicated that we need to inject values
/// @param _type Indicated the type of the input
function isReplaceable(uint8 _type) internal pure returns (bool) {
return _type != NO_PARAM_MAPPING;
}
/// @notice Checks if the paramMapping value is in the return value range
/// @param _type Indicated the type of the input
function isReturnInjection(uint8 _type) internal pure returns (bool) {
return (_type >= RETURN_MIN_INDEX_VALUE) && (_type <= RETURN_MAX_INDEX_VALUE);
}
/// @notice Transforms the paramMapping value to the index in return array value
/// @param _type Indicated the type of the input
function getReturnIndex(uint8 _type) internal pure returns (uint8) {
require(isReturnInjection(_type), ERR_SUB_INDEX_VALUE);
return (_type - RETURN_MIN_INDEX_VALUE);
}
/// @notice Transforms the paramMapping value to the index in sub array value
/// @param _type Indicated the type of the input
function getSubIndex(uint8 _type) internal pure returns (uint8) {
require(_type >= SUB_MIN_INDEX_VALUE, ERR_RETURN_INDEX_VALUE);
return (_type - SUB_MIN_INDEX_VALUE);
}
}
contract StrategyData {
struct Template {
string name;
bytes32[] triggerIds;
bytes32[] actionIds;
uint8[][] paramMapping;
}
struct Task {
string name;
bytes[][] callData;
bytes[][] subData;
bytes32[] actionIds;
uint8[][] paramMapping;
}
struct Strategy {
uint templateId;
address proxy;
bytes[][] subData;
bytes[][] triggerData;
bool active;
uint posInUserArr;
}
}
interface IFlashLoanRecipient {
/**
* @dev When `flashLoan` is called on the Vault, it invokes the `receiveFlashLoan` hook on the recipient.
*
* At the time of the call, the Vault will have transferred `amounts` for `tokens` to the recipient. Before this
* call returns, the recipient must have transferred `amounts` plus `feeAmounts` for each token back to the
* Vault, or else the entire flash loan will revert.
*
* `userData` is the same value passed in the `IVault.flashLoan` call.
*/
function receiveFlashLoan(
address[] memory tokens,
uint256[] memory amounts,
uint256[] memory feeAmounts,
bytes memory userData
) external;
}
interface IFlashLoans {
function flashLoan(
address recipient,
address[] memory tokens,
uint256[] memory amounts,
bytes memory userData
) external;
}
abstract contract IDSProxy {
// function execute(bytes memory _code, bytes memory _data)
// public
// payable
// virtual
// returns (address, bytes32);
function execute(address _target, bytes memory _data) public payable virtual returns (bytes32);
function setCache(address _cacheAddr) public payable virtual returns (bool);
function owner() public view virtual returns (address);
}
abstract contract IFLParamGetter {
function getFlashLoanParams(bytes memory _data)
public
view
virtual
returns (
address[] memory tokens,
uint256[] memory amount,
uint256[] memory modes
);
}
abstract contract IWETH {
function allowance(address, address) public virtual view returns (uint256);
function balanceOf(address) public virtual view returns (uint256);
function approve(address, uint256) public virtual;
function transfer(address, uint256) public virtual returns (bool);
function transferFrom(
address,
address,
uint256
) public virtual returns (bool);
function deposit() public payable virtual;
function withdraw(uint256) public virtual;
}
library TokenUtils {
using SafeERC20 for IERC20;
address public constant WETH_ADDR = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address public constant ETH_ADDR = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
function approveToken(
address _tokenAddr,
address _to,
uint256 _amount
) internal {
if (_tokenAddr == ETH_ADDR) return;
if (IERC20(_tokenAddr).allowance(address(this), _to) < _amount) {
IERC20(_tokenAddr).safeApprove(_to, _amount);
}
}
function pullTokensIfNeeded(
address _token,
address _from,
uint256 _amount
) internal returns (uint256) {
// handle max uint amount
if (_amount == type(uint256).max) {
_amount = getBalance(_token, _from);
}
if (_from != address(0) && _from != address(this) && _token != ETH_ADDR && _amount != 0) {
IERC20(_token).safeTransferFrom(_from, address(this), _amount);
}
return _amount;
}
function withdrawTokens(
address _token,
address _to,
uint256 _amount
) internal returns (uint256) {
if (_amount == type(uint256).max) {
_amount = getBalance(_token, address(this));
}
if (_to != address(0) && _to != address(this) && _amount != 0) {
if (_token != ETH_ADDR) {
IERC20(_token).safeTransfer(_to, _amount);
} else {
payable(_to).transfer(_amount);
}
}
return _amount;
}
function depositWeth(uint256 _amount) internal {
IWETH(WETH_ADDR).deposit{value: _amount}();
}
function withdrawWeth(uint256 _amount) internal {
IWETH(WETH_ADDR).withdraw(_amount);
}
function getBalance(address _tokenAddr, address _acc) internal view returns (uint256) {
if (_tokenAddr == ETH_ADDR) {
return _acc.balance;
} else {
return IERC20(_tokenAddr).balanceOf(_acc);
}
}
function getTokenDecimals(address _token) internal view returns (uint256) {
if (_token == ETH_ADDR) return 18;
return IERC20(_token).decimals();
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract FLBalancer is ActionBase, ReentrancyGuard, IFlashLoanRecipient, BalancerV2Helper {
using TokenUtils for address;
using SafeMath for uint256;
/// @dev Function sig of TaskExecutor._executeActionsFromFL()
bytes4 public constant CALLBACK_SELECTOR = 0xd6741b9e;
bytes32 constant TASK_EXECUTOR_ID = keccak256("TaskExecutor");
bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
struct Params {
address[] tokens; // Tokens to flash borrow
uint256[] amounts; // Token amounts
address flParamGetterAddr; // On-chain contract used for piping FL action parameters
bytes flParamGetterData; // Data to supply to flParamGetter
}
function executeAction(
bytes[] memory _callData,
bytes[] memory,
uint8[] memory,
bytes32[] memory
) public override payable returns (bytes32) {
Params memory params = parseInputs(_callData);
if (params.flParamGetterAddr != address(0)) {
(params.tokens, params.amounts,) =
IFLParamGetter(params.flParamGetterAddr).getFlashLoanParams(params.flParamGetterData);
}
bytes memory taskData = _callData[_callData.length - 1];
uint256 amount = _flBalancer(params, taskData);
return bytes32(amount);
}
// solhint-disable-next-line no-empty-blocks
function executeActionDirect(bytes[] memory _callData) public override payable {}
/// @inheritdoc ActionBase
function actionType() public override pure returns (uint8) {
return uint8(ActionType.FL_ACTION);
}
/// @notice Gets a FL from Balancer and returns back the execution to the action address
function _flBalancer(Params memory _params, bytes memory _taskData) internal returns (uint256) {
IFlashLoans(VAULT_ADDR).flashLoan(
address(this),
_params.tokens,
_params.amounts,
_taskData
);
logger.Log(
address(this),
msg.sender,
"FLBalancer",
abi.encode(
_params
)
);
return _params.amounts[0];
}
/// @notice Balancer FL callback function that formats and calls back TaskExecutor
function receiveFlashLoan(
address[] memory _tokens,
uint256[] memory _amounts,
uint256[] memory _feeAmounts,
bytes memory _userData
) external override nonReentrant {
require(msg.sender == VAULT_ADDR, "Untrusted lender");
(StrategyData.Task memory currTask, address proxy) = abi.decode(_userData, (StrategyData.Task, address));
for (uint256 i = 0; i < _tokens.length; i++) {
_tokens[i].withdrawTokens(proxy, _amounts[i]);
}
address payable taskExecutor = payable(registry.getAddr(TASK_EXECUTOR_ID));
// call Action execution
IDSProxy(proxy).execute{value: address(this).balance}(
taskExecutor,
abi.encodeWithSelector(CALLBACK_SELECTOR, currTask, _amounts[0].add(_feeAmounts[0]))
);
for (uint256 i = 0; i < _tokens.length; i++) {
uint256 paybackAmount = _amounts[i].add(_feeAmounts[i]);
require(_tokens[i].getBalance(address(this)) == paybackAmount, "Wrong payback amount");
_tokens[i].withdrawTokens(address(VAULT_ADDR), paybackAmount);
}
}
function parseInputs(bytes[] memory _callData)
public
pure
returns (Params memory params)
{
params = abi.decode(_callData[0], (Params));
}
}
| On-chain contract used for piping FL action parameters
| address flParamGetterAddr; | 6,848,888 | [
1,
1398,
17,
5639,
6835,
1399,
364,
8341,
310,
31358,
1301,
1472,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
1758,
1183,
786,
8461,
3178,
31,
282,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/1/0xbc446fA602Ece8A4fD163cD356B598ef1C8aaE4E/sources/lib/core-cash/src/libraries/ProductIdUtil.sol | * @title ProductIdUtil @dev used to parse and compose productId Product Id = ----------------- | ----------------- | ---------------------- | ------------------ | ---------------------- | oracleId (8 bits) | engineId (8 bits) | underlying ID (8 bits) | strike ID (8 bits) | collateral ID (8 bits) | ----------------- | ----------------- | ---------------------- | ------------------ | ---------------------- / | library ProductIdUtil {
function parseProductId(uint40 _productId)
internal
pure
returns (uint8 oracleId, uint8 engineId, uint8 underlyingId, uint8 strikeId, uint8 collateralId)
pragma solidity ^0.8.0;
{
assembly {
oracleId := shr(32, _productId)
engineId := shr(24, _productId)
underlyingId := shr(16, _productId)
strikeId := shr(8, _productId)
}
collateralId = uint8(_productId);
}
{
assembly {
oracleId := shr(32, _productId)
engineId := shr(24, _productId)
underlyingId := shr(16, _productId)
strikeId := shr(8, _productId)
}
collateralId = uint8(_productId);
}
function getCollateralId(uint40 _productId) internal pure returns (uint8) {
return uint8(_productId);
}
function getProductId(uint8 oracleId, uint8 engineId, uint8 underlyingId, uint8 strikeId, uint8 collateralId)
internal
pure
returns (uint40 id)
{
unchecked {
id = (uint40(oracleId) << 32) + (uint40(engineId) << 24) + (uint40(underlyingId) << 16) + (uint40(strikeId) << 8)
+ (uint40(collateralId));
}
}
function getProductId(uint8 oracleId, uint8 engineId, uint8 underlyingId, uint8 strikeId, uint8 collateralId)
internal
pure
returns (uint40 id)
{
unchecked {
id = (uint40(oracleId) << 32) + (uint40(engineId) << 24) + (uint40(underlyingId) << 16) + (uint40(strikeId) << 8)
+ (uint40(collateralId));
}
}
}
| 4,192,636 | [
1,
19268,
1304,
225,
1399,
358,
1109,
471,
11458,
23820,
8094,
3124,
273,
225,
12146,
571,
12146,
571,
12146,
13465,
571,
12146,
17,
571,
12146,
13465,
225,
571,
20865,
548,
261,
28,
4125,
13,
571,
4073,
548,
261,
28,
4125,
13,
571,
6808,
1599,
261,
28,
4125,
13,
571,
609,
2547,
1599,
261,
28,
4125,
13,
571,
4508,
2045,
287,
1599,
261,
28,
4125,
13,
571,
225,
12146,
571,
12146,
571,
12146,
13465,
571,
12146,
17,
571,
12146,
13465,
342,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
12083,
8094,
548,
1304,
288,
203,
565,
445,
1109,
19268,
12,
11890,
7132,
389,
5896,
548,
13,
203,
3639,
2713,
203,
3639,
16618,
203,
3639,
1135,
261,
11890,
28,
20865,
548,
16,
2254,
28,
4073,
548,
16,
2254,
28,
6808,
548,
16,
2254,
28,
609,
2547,
548,
16,
2254,
28,
4508,
2045,
287,
548,
13,
203,
683,
9454,
18035,
560,
3602,
20,
18,
28,
18,
20,
31,
203,
203,
565,
288,
203,
3639,
19931,
288,
203,
5411,
20865,
548,
519,
699,
86,
12,
1578,
16,
389,
5896,
548,
13,
203,
5411,
4073,
548,
519,
699,
86,
12,
3247,
16,
389,
5896,
548,
13,
203,
5411,
6808,
548,
519,
699,
86,
12,
2313,
16,
389,
5896,
548,
13,
203,
5411,
609,
2547,
548,
519,
699,
86,
12,
28,
16,
389,
5896,
548,
13,
203,
3639,
289,
203,
3639,
4508,
2045,
287,
548,
273,
2254,
28,
24899,
5896,
548,
1769,
203,
565,
289,
203,
203,
565,
288,
203,
3639,
19931,
288,
203,
5411,
20865,
548,
519,
699,
86,
12,
1578,
16,
389,
5896,
548,
13,
203,
5411,
4073,
548,
519,
699,
86,
12,
3247,
16,
389,
5896,
548,
13,
203,
5411,
6808,
548,
519,
699,
86,
12,
2313,
16,
389,
5896,
548,
13,
203,
5411,
609,
2547,
548,
519,
699,
86,
12,
28,
16,
389,
5896,
548,
13,
203,
3639,
289,
203,
3639,
4508,
2045,
287,
548,
273,
2254,
28,
24899,
5896,
548,
1769,
203,
565,
289,
203,
203,
565,
445,
336,
13535,
2045,
287,
548,
12,
11890,
7132,
389,
5896,
548,
13,
2713,
16618,
1135,
2
] |
./full_match/1/0x45F97D07dAB04B21F36fA3b1149c35e316b35d03/sources/contracts/PirexCvx.sol | / Allow PirexFees to distribute fees directly from sender Distribute fees | function initiateRedemptions(
uint256[] calldata lockIndexes,
Futures f,
uint256[] calldata assets,
address receiver
) external whenNotPaused nonReentrant {
uint256 lockLen = lockIndexes.length;
if (lockLen == 0) revert EmptyArray();
if (lockLen != assets.length) revert MismatchedArrayLengths();
emit InitiateRedemptions(lockIndexes, f, assets, receiver);
(, , , ICvxLocker.LockedBalance[] memory lockData) = cvxLocker
.lockedBalances(address(this));
uint256 totalAssets;
uint256 feeAmount;
uint256 feeMin = fees[Fees.RedemptionMin];
uint256 feeMax = fees[Fees.RedemptionMax];
for (uint256 i; i < lockLen; ++i) {
totalAssets += assets[i];
feeAmount += _initiateRedemption(
lockData[lockIndexes[i]],
f,
assets[i],
receiver,
feeMin,
feeMax
);
}
if (feeAmount != 0) {
pxCvx.operatorApprove(msg.sender, address(pirexFees), feeAmount);
pirexFees.distributeFees(msg.sender, address(pxCvx), feeAmount);
}
}
@param unlockTimes uint256[] CVX unlock timestamps
@param assets uint256[] upxCVX amounts
@param receiver address Receives CVX
| 16,476,795 | [
1,
19,
7852,
453,
577,
92,
2954,
281,
358,
25722,
1656,
281,
5122,
628,
5793,
3035,
887,
1656,
281,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
18711,
426,
19117,
573,
12,
203,
3639,
2254,
5034,
8526,
745,
892,
2176,
8639,
16,
203,
3639,
478,
10945,
284,
16,
203,
3639,
2254,
5034,
8526,
745,
892,
7176,
16,
203,
3639,
1758,
5971,
203,
565,
262,
3903,
1347,
1248,
28590,
1661,
426,
8230,
970,
288,
203,
3639,
2254,
5034,
2176,
2891,
273,
2176,
8639,
18,
2469,
31,
203,
203,
3639,
309,
261,
739,
2891,
422,
374,
13,
15226,
8953,
1076,
5621,
203,
3639,
309,
261,
739,
2891,
480,
7176,
18,
2469,
13,
15226,
26454,
1076,
22406,
5621,
203,
203,
3639,
3626,
26615,
426,
19117,
573,
12,
739,
8639,
16,
284,
16,
7176,
16,
5971,
1769,
203,
203,
3639,
261,
16,
269,
269,
26899,
26982,
2531,
264,
18,
8966,
13937,
8526,
3778,
2176,
751,
13,
273,
8951,
92,
2531,
264,
203,
5411,
263,
15091,
38,
26488,
12,
2867,
12,
2211,
10019,
203,
3639,
2254,
5034,
2078,
10726,
31,
203,
3639,
2254,
5034,
14036,
6275,
31,
203,
3639,
2254,
5034,
14036,
2930,
273,
1656,
281,
63,
2954,
281,
18,
426,
19117,
375,
2930,
15533,
203,
3639,
2254,
5034,
14036,
2747,
273,
1656,
281,
63,
2954,
281,
18,
426,
19117,
375,
2747,
15533,
203,
203,
3639,
364,
261,
11890,
5034,
277,
31,
277,
411,
2176,
2891,
31,
965,
77,
13,
288,
203,
5411,
2078,
10726,
1011,
7176,
63,
77,
15533,
203,
5411,
14036,
6275,
1011,
389,
2738,
3840,
426,
19117,
375,
12,
203,
7734,
2176,
751,
63,
739,
8639,
63,
77,
65,
6487,
203,
7734,
284,
16,
203,
7734,
7176,
63,
77,
6487,
203,
2
] |
pragma solidity ^0.5.0;
import "truffle/Assert.sol";
import "truffle/DeployedAddresses.sol";
import "../contracts/Purchase.sol";
contract TestPurchase {
// The address of the purchase contract to be tested
Purchase purchase = Purchase(DeployedAddresses.Purchase());
// Testing the purchase() function
function testUserCanBuyBook() public {
uint returnedId = purchase.purchase(expectedBookId);
Assert.equal(returnedId, expectedBookId, "Purchase of the expected book should match what is returned.");
}
// Testing retrieval of a single book's customer
function testGetCustomerAddressByBookId() public {
address customer = purchase.customers(expectedBookId);
Assert.equal(customer, expectedCustomer, "Buyer of the expected book should be this contract.");
}
// Testing retrieval of all book customers
function testGetCustomerAddressByBookIdInArray() public {
//Store customers in memory rather than contract's storage
address[16] memory customers = purchase.getCustomers();
Assert.equal(customers[expectedBookId], expectedCustomer, "Buyer of the expected book should be this contract.");
}
// The id of the book that will be used for testing
uint expectedBookId = 3;
// The expected buyer of book is this contract
address expectedCustomer = address(this);
}
| Testing retrieval of a single book's customer | function testGetCustomerAddressByBookId() public {
address customer = purchase.customers(expectedBookId);
Assert.equal(customer, expectedCustomer, "Buyer of the expected book should be this contract.");
}
| 5,422,536 | [
1,
22218,
22613,
434,
279,
2202,
6978,
1807,
6666,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
225,
445,
1842,
967,
8883,
1887,
858,
9084,
548,
1435,
1071,
288,
203,
565,
1758,
6666,
273,
23701,
18,
3662,
414,
12,
3825,
9084,
548,
1769,
203,
203,
565,
5452,
18,
9729,
12,
10061,
16,
2665,
8883,
16,
315,
38,
16213,
434,
326,
2665,
6978,
1410,
506,
333,
6835,
1199,
1769,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/42/0x53AF86B01ca8668D7a5F52E3361D4Bc7A331bfdf/sources/BirdCore.sol | * @title Bird's BToken Contract @notice Abstract base for BTokens/ testing event to check what is failing | contract BToken is BTokenInterface, Exponential, TokenErrorReporter {
event AllowedTestEvent(address indexed user, address indexed bToken, uint256 errorCode);
function initialize(BControllerInterface bController_,
InterestRateModel interestRateModel_,
uint initialExchangeRateMantissa_,
string memory name_,
string memory symbol_,
}
uint8 decimals_) public {
require(msg.sender == admin, "only admin may initialize the market");
require(accrualBlockNumber == 0 && borrowIndex == 0, "market may only be initialized once");
initialExchangeRateMantissa = initialExchangeRateMantissa_;
require(initialExchangeRateMantissa > 0, "initial exchange rate must be greater than zero.");
uint err = _setBController(bController_);
require(err == uint(Error.NO_ERROR), "setting bController failed");
accrualBlockNumber = getBlockNumber();
borrowIndex = mantissaOne;
err = _setInterestRateModelFresh(interestRateModel_);
require(err == uint(Error.NO_ERROR), "setting interest rate model failed");
name = name_;
symbol = symbol_;
decimals = decimals_;
_notEntered = true;
}
function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) {
uint allowed = bController.transferAllowed(address(this), src, dst, tokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.TRANSFER_BCONTROLLER_REJECTION, allowed);
}
if (src == dst) {
return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED);
}
if (spender == src) {
startingAllowance = uint(-1);
startingAllowance = transferAllowances[src][spender];
}
uint allowanceNew;
uint scrTokensNew;
uint dstTokensNew;
(mathErr, allowanceNew) = subUInt(startingAllowance, tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED);
}
(mathErr, scrTokensNew) = subUInt(accountTokens[src], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH);
}
(mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH);
}
accountTokens[src] = scrTokensNew;
accountTokens[dst] = dstTokensNew;
if (startingAllowance != uint(-1)) {
transferAllowances[src][spender] = allowanceNew;
}
bController.transferVerify(address(this), src, dst, tokens);
return uint(Error.NO_ERROR);
}
function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) {
uint allowed = bController.transferAllowed(address(this), src, dst, tokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.TRANSFER_BCONTROLLER_REJECTION, allowed);
}
if (src == dst) {
return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED);
}
if (spender == src) {
startingAllowance = uint(-1);
startingAllowance = transferAllowances[src][spender];
}
uint allowanceNew;
uint scrTokensNew;
uint dstTokensNew;
(mathErr, allowanceNew) = subUInt(startingAllowance, tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED);
}
(mathErr, scrTokensNew) = subUInt(accountTokens[src], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH);
}
(mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH);
}
accountTokens[src] = scrTokensNew;
accountTokens[dst] = dstTokensNew;
if (startingAllowance != uint(-1)) {
transferAllowances[src][spender] = allowanceNew;
}
bController.transferVerify(address(this), src, dst, tokens);
return uint(Error.NO_ERROR);
}
function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) {
uint allowed = bController.transferAllowed(address(this), src, dst, tokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.TRANSFER_BCONTROLLER_REJECTION, allowed);
}
if (src == dst) {
return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED);
}
if (spender == src) {
startingAllowance = uint(-1);
startingAllowance = transferAllowances[src][spender];
}
uint allowanceNew;
uint scrTokensNew;
uint dstTokensNew;
(mathErr, allowanceNew) = subUInt(startingAllowance, tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED);
}
(mathErr, scrTokensNew) = subUInt(accountTokens[src], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH);
}
(mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH);
}
accountTokens[src] = scrTokensNew;
accountTokens[dst] = dstTokensNew;
if (startingAllowance != uint(-1)) {
transferAllowances[src][spender] = allowanceNew;
}
bController.transferVerify(address(this), src, dst, tokens);
return uint(Error.NO_ERROR);
}
uint startingAllowance = 0;
function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) {
uint allowed = bController.transferAllowed(address(this), src, dst, tokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.TRANSFER_BCONTROLLER_REJECTION, allowed);
}
if (src == dst) {
return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED);
}
if (spender == src) {
startingAllowance = uint(-1);
startingAllowance = transferAllowances[src][spender];
}
uint allowanceNew;
uint scrTokensNew;
uint dstTokensNew;
(mathErr, allowanceNew) = subUInt(startingAllowance, tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED);
}
(mathErr, scrTokensNew) = subUInt(accountTokens[src], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH);
}
(mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH);
}
accountTokens[src] = scrTokensNew;
accountTokens[dst] = dstTokensNew;
if (startingAllowance != uint(-1)) {
transferAllowances[src][spender] = allowanceNew;
}
bController.transferVerify(address(this), src, dst, tokens);
return uint(Error.NO_ERROR);
}
} else {
MathError mathErr;
function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) {
uint allowed = bController.transferAllowed(address(this), src, dst, tokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.TRANSFER_BCONTROLLER_REJECTION, allowed);
}
if (src == dst) {
return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED);
}
if (spender == src) {
startingAllowance = uint(-1);
startingAllowance = transferAllowances[src][spender];
}
uint allowanceNew;
uint scrTokensNew;
uint dstTokensNew;
(mathErr, allowanceNew) = subUInt(startingAllowance, tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED);
}
(mathErr, scrTokensNew) = subUInt(accountTokens[src], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH);
}
(mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH);
}
accountTokens[src] = scrTokensNew;
accountTokens[dst] = dstTokensNew;
if (startingAllowance != uint(-1)) {
transferAllowances[src][spender] = allowanceNew;
}
bController.transferVerify(address(this), src, dst, tokens);
return uint(Error.NO_ERROR);
}
function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) {
uint allowed = bController.transferAllowed(address(this), src, dst, tokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.TRANSFER_BCONTROLLER_REJECTION, allowed);
}
if (src == dst) {
return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED);
}
if (spender == src) {
startingAllowance = uint(-1);
startingAllowance = transferAllowances[src][spender];
}
uint allowanceNew;
uint scrTokensNew;
uint dstTokensNew;
(mathErr, allowanceNew) = subUInt(startingAllowance, tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED);
}
(mathErr, scrTokensNew) = subUInt(accountTokens[src], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH);
}
(mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH);
}
accountTokens[src] = scrTokensNew;
accountTokens[dst] = dstTokensNew;
if (startingAllowance != uint(-1)) {
transferAllowances[src][spender] = allowanceNew;
}
bController.transferVerify(address(this), src, dst, tokens);
return uint(Error.NO_ERROR);
}
function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) {
uint allowed = bController.transferAllowed(address(this), src, dst, tokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.TRANSFER_BCONTROLLER_REJECTION, allowed);
}
if (src == dst) {
return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED);
}
if (spender == src) {
startingAllowance = uint(-1);
startingAllowance = transferAllowances[src][spender];
}
uint allowanceNew;
uint scrTokensNew;
uint dstTokensNew;
(mathErr, allowanceNew) = subUInt(startingAllowance, tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED);
}
(mathErr, scrTokensNew) = subUInt(accountTokens[src], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH);
}
(mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH);
}
accountTokens[src] = scrTokensNew;
accountTokens[dst] = dstTokensNew;
if (startingAllowance != uint(-1)) {
transferAllowances[src][spender] = allowanceNew;
}
bController.transferVerify(address(this), src, dst, tokens);
return uint(Error.NO_ERROR);
}
function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) {
uint allowed = bController.transferAllowed(address(this), src, dst, tokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.TRANSFER_BCONTROLLER_REJECTION, allowed);
}
if (src == dst) {
return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED);
}
if (spender == src) {
startingAllowance = uint(-1);
startingAllowance = transferAllowances[src][spender];
}
uint allowanceNew;
uint scrTokensNew;
uint dstTokensNew;
(mathErr, allowanceNew) = subUInt(startingAllowance, tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED);
}
(mathErr, scrTokensNew) = subUInt(accountTokens[src], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH);
}
(mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens);
if (mathErr != MathError.NO_ERROR) {
return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH);
}
accountTokens[src] = scrTokensNew;
accountTokens[dst] = dstTokensNew;
if (startingAllowance != uint(-1)) {
transferAllowances[src][spender] = allowanceNew;
}
bController.transferVerify(address(this), src, dst, tokens);
return uint(Error.NO_ERROR);
}
emit Transfer(src, dst, tokens);
function transfer(address dst, uint256 amount) external nonReentrant returns (bool) {
return transferTokens(msg.sender, msg.sender, dst, amount) == uint(Error.NO_ERROR);
}
function transferFrom(address src, address dst, uint256 amount) external nonReentrant returns (bool) {
return transferTokens(msg.sender, src, dst, amount) == uint(Error.NO_ERROR);
}
function approve(address spender, uint256 amount) external returns (bool) {
address src = msg.sender;
transferAllowances[src][spender] = amount;
emit Approval(src, spender, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return transferAllowances[owner][spender];
}
function balanceOf(address owner) external view returns (uint256) {
return accountTokens[owner];
}
function balanceOfUnderlying(address owner) external returns (uint) {
(MathError mErr, uint balance) = mulScalarTruncate(exchangeRate, accountTokens[owner]);
require(mErr == MathError.NO_ERROR, "balance could not be calculated");
return balance;
}
Exp memory exchangeRate = Exp({mantissa: exchangeRateCurrent()});
function getAccountSnapshot(address account) external view returns (uint, uint, uint, uint) {
uint bTokenBalance = accountTokens[account];
uint borrowBalance;
uint exchangeRateMantissa;
MathError mErr;
(mErr, borrowBalance) = borrowBalanceStoredInternal(account);
if (mErr != MathError.NO_ERROR) {
return (uint(Error.MATH_ERROR), 0, 0, 0);
}
(mErr, exchangeRateMantissa) = exchangeRateStoredInternal();
if (mErr != MathError.NO_ERROR) {
return (uint(Error.MATH_ERROR), 0, 0, 0);
}
return (uint(Error.NO_ERROR), bTokenBalance, borrowBalance, exchangeRateMantissa);
}
function getAccountSnapshot(address account) external view returns (uint, uint, uint, uint) {
uint bTokenBalance = accountTokens[account];
uint borrowBalance;
uint exchangeRateMantissa;
MathError mErr;
(mErr, borrowBalance) = borrowBalanceStoredInternal(account);
if (mErr != MathError.NO_ERROR) {
return (uint(Error.MATH_ERROR), 0, 0, 0);
}
(mErr, exchangeRateMantissa) = exchangeRateStoredInternal();
if (mErr != MathError.NO_ERROR) {
return (uint(Error.MATH_ERROR), 0, 0, 0);
}
return (uint(Error.NO_ERROR), bTokenBalance, borrowBalance, exchangeRateMantissa);
}
function getAccountSnapshot(address account) external view returns (uint, uint, uint, uint) {
uint bTokenBalance = accountTokens[account];
uint borrowBalance;
uint exchangeRateMantissa;
MathError mErr;
(mErr, borrowBalance) = borrowBalanceStoredInternal(account);
if (mErr != MathError.NO_ERROR) {
return (uint(Error.MATH_ERROR), 0, 0, 0);
}
(mErr, exchangeRateMantissa) = exchangeRateStoredInternal();
if (mErr != MathError.NO_ERROR) {
return (uint(Error.MATH_ERROR), 0, 0, 0);
}
return (uint(Error.NO_ERROR), bTokenBalance, borrowBalance, exchangeRateMantissa);
}
function getBlockNumber() internal view returns (uint) {
return block.number;
}
function borrowRatePerBlock() external view returns (uint) {
return interestRateModel.getBorrowRate(getCashPrior(), totalBorrows, totalReserves);
}
function supplyRatePerBlock() external view returns (uint) {
return interestRateModel.getSupplyRate(getCashPrior(), totalBorrows, totalReserves, reserveFactorMantissa);
}
function totalBorrowsCurrent() external nonReentrant returns (uint) {
require(accrueInterest() == uint(Error.NO_ERROR), "accrue interest failed");
return totalBorrows;
}
function borrowBalanceCurrent(address account) external nonReentrant returns (uint) {
require(accrueInterest() == uint(Error.NO_ERROR), "accrue interest failed");
return borrowBalanceStored(account);
}
function borrowBalanceStored(address account) public view returns (uint) {
(MathError err, uint result) = borrowBalanceStoredInternal(account);
require(err == MathError.NO_ERROR, "borrowBalanceStored: borrowBalanceStoredInternal failed");
return result;
}
function borrowBalanceStoredInternal(address account) internal view returns (MathError, uint) {
MathError mathErr;
uint principalTimesIndex;
uint result;
BorrowSnapshot storage borrowSnapshot = accountBorrows[account];
if (borrowSnapshot.principal == 0) {
return (MathError.NO_ERROR, 0);
}
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
(mathErr, result) = divUInt(principalTimesIndex, borrowSnapshot.interestIndex);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
return (MathError.NO_ERROR, result);
}
function borrowBalanceStoredInternal(address account) internal view returns (MathError, uint) {
MathError mathErr;
uint principalTimesIndex;
uint result;
BorrowSnapshot storage borrowSnapshot = accountBorrows[account];
if (borrowSnapshot.principal == 0) {
return (MathError.NO_ERROR, 0);
}
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
(mathErr, result) = divUInt(principalTimesIndex, borrowSnapshot.interestIndex);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
return (MathError.NO_ERROR, result);
}
(mathErr, principalTimesIndex) = mulUInt(borrowSnapshot.principal, borrowIndex);
function borrowBalanceStoredInternal(address account) internal view returns (MathError, uint) {
MathError mathErr;
uint principalTimesIndex;
uint result;
BorrowSnapshot storage borrowSnapshot = accountBorrows[account];
if (borrowSnapshot.principal == 0) {
return (MathError.NO_ERROR, 0);
}
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
(mathErr, result) = divUInt(principalTimesIndex, borrowSnapshot.interestIndex);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
return (MathError.NO_ERROR, result);
}
function borrowBalanceStoredInternal(address account) internal view returns (MathError, uint) {
MathError mathErr;
uint principalTimesIndex;
uint result;
BorrowSnapshot storage borrowSnapshot = accountBorrows[account];
if (borrowSnapshot.principal == 0) {
return (MathError.NO_ERROR, 0);
}
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
(mathErr, result) = divUInt(principalTimesIndex, borrowSnapshot.interestIndex);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
return (MathError.NO_ERROR, result);
}
function exchangeRateCurrent() public nonReentrant returns (uint) {
require(accrueInterest() == uint(Error.NO_ERROR), "accrue interest failed");
return exchangeRateStored();
}
function exchangeRateStored() public view returns (uint) {
(MathError err, uint result) = exchangeRateStoredInternal();
require(err == MathError.NO_ERROR, "exchangeRateStored: exchangeRateStoredInternal failed");
return result;
}
function exchangeRateStoredInternal() internal view returns (MathError, uint) {
uint _totalSupply = totalSupply;
if (_totalSupply == 0) {
return (MathError.NO_ERROR, initialExchangeRateMantissa);
uint totalCash = getCashPrior();
uint cashPlusBorrowsMinusReserves;
Exp memory exchangeRate;
MathError mathErr;
(mathErr, cashPlusBorrowsMinusReserves) = addThenSubUInt(totalCash, totalBorrows, totalReserves);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
(mathErr, exchangeRate) = getExp(cashPlusBorrowsMinusReserves, _totalSupply);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
return (MathError.NO_ERROR, exchangeRate.mantissa);
}
}
function exchangeRateStoredInternal() internal view returns (MathError, uint) {
uint _totalSupply = totalSupply;
if (_totalSupply == 0) {
return (MathError.NO_ERROR, initialExchangeRateMantissa);
uint totalCash = getCashPrior();
uint cashPlusBorrowsMinusReserves;
Exp memory exchangeRate;
MathError mathErr;
(mathErr, cashPlusBorrowsMinusReserves) = addThenSubUInt(totalCash, totalBorrows, totalReserves);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
(mathErr, exchangeRate) = getExp(cashPlusBorrowsMinusReserves, _totalSupply);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
return (MathError.NO_ERROR, exchangeRate.mantissa);
}
}
} else {
function exchangeRateStoredInternal() internal view returns (MathError, uint) {
uint _totalSupply = totalSupply;
if (_totalSupply == 0) {
return (MathError.NO_ERROR, initialExchangeRateMantissa);
uint totalCash = getCashPrior();
uint cashPlusBorrowsMinusReserves;
Exp memory exchangeRate;
MathError mathErr;
(mathErr, cashPlusBorrowsMinusReserves) = addThenSubUInt(totalCash, totalBorrows, totalReserves);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
(mathErr, exchangeRate) = getExp(cashPlusBorrowsMinusReserves, _totalSupply);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
return (MathError.NO_ERROR, exchangeRate.mantissa);
}
}
function exchangeRateStoredInternal() internal view returns (MathError, uint) {
uint _totalSupply = totalSupply;
if (_totalSupply == 0) {
return (MathError.NO_ERROR, initialExchangeRateMantissa);
uint totalCash = getCashPrior();
uint cashPlusBorrowsMinusReserves;
Exp memory exchangeRate;
MathError mathErr;
(mathErr, cashPlusBorrowsMinusReserves) = addThenSubUInt(totalCash, totalBorrows, totalReserves);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
(mathErr, exchangeRate) = getExp(cashPlusBorrowsMinusReserves, _totalSupply);
if (mathErr != MathError.NO_ERROR) {
return (mathErr, 0);
}
return (MathError.NO_ERROR, exchangeRate.mantissa);
}
}
function getCash() external view returns (uint) {
return getCashPrior();
}
function accrueInterest() public returns (uint) {
uint currentBlockNumber = getBlockNumber();
uint accrualBlockNumberPrior = accrualBlockNumber;
if (accrualBlockNumberPrior == currentBlockNumber) {
return uint(Error.NO_ERROR);
}
uint borrowsPrior = totalBorrows;
uint reservesPrior = totalReserves;
uint borrowIndexPrior = borrowIndex;
require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
require(mathErr == MathError.NO_ERROR, "could not calculate block delta");
Exp memory simpleInterestFactor;
uint interestAccumulated;
uint totalBorrowsNew;
uint totalReservesNew;
uint borrowIndexNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, interestAccumulated) = mulScalarTruncate(simpleInterestFactor, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, totalBorrowsNew) = addUInt(interestAccumulated, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, uint(mathErr));
}
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, borrowIndexNew) = mulScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, uint(mathErr));
}
borrowIndex = borrowIndexNew;
totalBorrows = totalBorrowsNew;
totalReserves = totalReservesNew;
return uint(Error.NO_ERROR);
}
function accrueInterest() public returns (uint) {
uint currentBlockNumber = getBlockNumber();
uint accrualBlockNumberPrior = accrualBlockNumber;
if (accrualBlockNumberPrior == currentBlockNumber) {
return uint(Error.NO_ERROR);
}
uint borrowsPrior = totalBorrows;
uint reservesPrior = totalReserves;
uint borrowIndexPrior = borrowIndex;
require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
require(mathErr == MathError.NO_ERROR, "could not calculate block delta");
Exp memory simpleInterestFactor;
uint interestAccumulated;
uint totalBorrowsNew;
uint totalReservesNew;
uint borrowIndexNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, interestAccumulated) = mulScalarTruncate(simpleInterestFactor, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, totalBorrowsNew) = addUInt(interestAccumulated, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, uint(mathErr));
}
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, borrowIndexNew) = mulScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, uint(mathErr));
}
borrowIndex = borrowIndexNew;
totalBorrows = totalBorrowsNew;
totalReserves = totalReservesNew;
return uint(Error.NO_ERROR);
}
uint cashPrior = getCashPrior();
uint borrowRateMantissa = interestRateModel.getBorrowRate(cashPrior, borrowsPrior, reservesPrior);
(MathError mathErr, uint blockDelta) = subUInt(currentBlockNumber, accrualBlockNumberPrior);
(mathErr, simpleInterestFactor) = mulScalar(Exp({mantissa: borrowRateMantissa}), blockDelta);
function accrueInterest() public returns (uint) {
uint currentBlockNumber = getBlockNumber();
uint accrualBlockNumberPrior = accrualBlockNumber;
if (accrualBlockNumberPrior == currentBlockNumber) {
return uint(Error.NO_ERROR);
}
uint borrowsPrior = totalBorrows;
uint reservesPrior = totalReserves;
uint borrowIndexPrior = borrowIndex;
require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
require(mathErr == MathError.NO_ERROR, "could not calculate block delta");
Exp memory simpleInterestFactor;
uint interestAccumulated;
uint totalBorrowsNew;
uint totalReservesNew;
uint borrowIndexNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, interestAccumulated) = mulScalarTruncate(simpleInterestFactor, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, totalBorrowsNew) = addUInt(interestAccumulated, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, uint(mathErr));
}
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, borrowIndexNew) = mulScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, uint(mathErr));
}
borrowIndex = borrowIndexNew;
totalBorrows = totalBorrowsNew;
totalReserves = totalReservesNew;
return uint(Error.NO_ERROR);
}
function accrueInterest() public returns (uint) {
uint currentBlockNumber = getBlockNumber();
uint accrualBlockNumberPrior = accrualBlockNumber;
if (accrualBlockNumberPrior == currentBlockNumber) {
return uint(Error.NO_ERROR);
}
uint borrowsPrior = totalBorrows;
uint reservesPrior = totalReserves;
uint borrowIndexPrior = borrowIndex;
require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
require(mathErr == MathError.NO_ERROR, "could not calculate block delta");
Exp memory simpleInterestFactor;
uint interestAccumulated;
uint totalBorrowsNew;
uint totalReservesNew;
uint borrowIndexNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, interestAccumulated) = mulScalarTruncate(simpleInterestFactor, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, totalBorrowsNew) = addUInt(interestAccumulated, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, uint(mathErr));
}
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, borrowIndexNew) = mulScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, uint(mathErr));
}
borrowIndex = borrowIndexNew;
totalBorrows = totalBorrowsNew;
totalReserves = totalReservesNew;
return uint(Error.NO_ERROR);
}
function accrueInterest() public returns (uint) {
uint currentBlockNumber = getBlockNumber();
uint accrualBlockNumberPrior = accrualBlockNumber;
if (accrualBlockNumberPrior == currentBlockNumber) {
return uint(Error.NO_ERROR);
}
uint borrowsPrior = totalBorrows;
uint reservesPrior = totalReserves;
uint borrowIndexPrior = borrowIndex;
require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
require(mathErr == MathError.NO_ERROR, "could not calculate block delta");
Exp memory simpleInterestFactor;
uint interestAccumulated;
uint totalBorrowsNew;
uint totalReservesNew;
uint borrowIndexNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, interestAccumulated) = mulScalarTruncate(simpleInterestFactor, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, totalBorrowsNew) = addUInt(interestAccumulated, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, uint(mathErr));
}
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, borrowIndexNew) = mulScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, uint(mathErr));
}
borrowIndex = borrowIndexNew;
totalBorrows = totalBorrowsNew;
totalReserves = totalReservesNew;
return uint(Error.NO_ERROR);
}
(mathErr, totalReservesNew) = mulScalarTruncateAddUInt(Exp({mantissa: reserveFactorMantissa}), interestAccumulated, reservesPrior);
function accrueInterest() public returns (uint) {
uint currentBlockNumber = getBlockNumber();
uint accrualBlockNumberPrior = accrualBlockNumber;
if (accrualBlockNumberPrior == currentBlockNumber) {
return uint(Error.NO_ERROR);
}
uint borrowsPrior = totalBorrows;
uint reservesPrior = totalReserves;
uint borrowIndexPrior = borrowIndex;
require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
require(mathErr == MathError.NO_ERROR, "could not calculate block delta");
Exp memory simpleInterestFactor;
uint interestAccumulated;
uint totalBorrowsNew;
uint totalReservesNew;
uint borrowIndexNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, interestAccumulated) = mulScalarTruncate(simpleInterestFactor, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, totalBorrowsNew) = addUInt(interestAccumulated, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, uint(mathErr));
}
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, borrowIndexNew) = mulScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, uint(mathErr));
}
borrowIndex = borrowIndexNew;
totalBorrows = totalBorrowsNew;
totalReserves = totalReservesNew;
return uint(Error.NO_ERROR);
}
function accrueInterest() public returns (uint) {
uint currentBlockNumber = getBlockNumber();
uint accrualBlockNumberPrior = accrualBlockNumber;
if (accrualBlockNumberPrior == currentBlockNumber) {
return uint(Error.NO_ERROR);
}
uint borrowsPrior = totalBorrows;
uint reservesPrior = totalReserves;
uint borrowIndexPrior = borrowIndex;
require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
require(mathErr == MathError.NO_ERROR, "could not calculate block delta");
Exp memory simpleInterestFactor;
uint interestAccumulated;
uint totalBorrowsNew;
uint totalReservesNew;
uint borrowIndexNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, interestAccumulated) = mulScalarTruncate(simpleInterestFactor, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, totalBorrowsNew) = addUInt(interestAccumulated, borrowsPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, uint(mathErr));
}
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, uint(mathErr));
}
(mathErr, borrowIndexNew) = mulScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, uint(mathErr));
}
borrowIndex = borrowIndexNew;
totalBorrows = totalBorrowsNew;
totalReserves = totalReservesNew;
return uint(Error.NO_ERROR);
}
accrualBlockNumber = currentBlockNumber;
emit AccrueInterestToken(cashPrior, interestAccumulated, borrowIndexNew, totalBorrowsNew);
function mintInternal(uint mintAmount) internal nonReentrant returns (uint, uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.MINT_ACCRUE_INTEREST_FAILED), 0);
}
}
function mintInternal(uint mintAmount) internal nonReentrant returns (uint, uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.MINT_ACCRUE_INTEREST_FAILED), 0);
}
}
return mintFresh(msg.sender, mintAmount);
struct MintLocalVars {
Error err;
MathError mathErr;
uint exchangeRateMantissa;
uint mintTokens;
uint totalSupplyNew;
uint accountTokensNew;
uint actualMintAmount;
}
function mintFresh(address minter, uint mintAmount) internal returns (uint, uint) {
uint allowed = bController.mintAllowed(address(this), minter, mintAmount);
emit AllowedTestEvent(minter, address(this), allowed);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.MINT_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.MINT_FRESHNESS_CHECK), 0);
}
MintLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return (failOpaque(Error.MATH_ERROR, FailureInfo.MINT_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)), 0);
}
require(vars.mathErr == MathError.NO_ERROR, "MINT_EXCHANGE_CALCULATION_FAILED");
require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_TOTAL_SUPPLY_CALCULATION_FAILED");
(vars.mathErr, vars.accountTokensNew) = addUInt(accountTokens[minter], vars.mintTokens);
require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED");
accountTokens[minter] = vars.accountTokensNew;
emit Transfer(address(this), minter, vars.mintTokens);
return (uint(Error.NO_ERROR), vars.actualMintAmount);
}
function mintFresh(address minter, uint mintAmount) internal returns (uint, uint) {
uint allowed = bController.mintAllowed(address(this), minter, mintAmount);
emit AllowedTestEvent(minter, address(this), allowed);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.MINT_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.MINT_FRESHNESS_CHECK), 0);
}
MintLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return (failOpaque(Error.MATH_ERROR, FailureInfo.MINT_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)), 0);
}
require(vars.mathErr == MathError.NO_ERROR, "MINT_EXCHANGE_CALCULATION_FAILED");
require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_TOTAL_SUPPLY_CALCULATION_FAILED");
(vars.mathErr, vars.accountTokensNew) = addUInt(accountTokens[minter], vars.mintTokens);
require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED");
accountTokens[minter] = vars.accountTokensNew;
emit Transfer(address(this), minter, vars.mintTokens);
return (uint(Error.NO_ERROR), vars.actualMintAmount);
}
function mintFresh(address minter, uint mintAmount) internal returns (uint, uint) {
uint allowed = bController.mintAllowed(address(this), minter, mintAmount);
emit AllowedTestEvent(minter, address(this), allowed);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.MINT_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.MINT_FRESHNESS_CHECK), 0);
}
MintLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return (failOpaque(Error.MATH_ERROR, FailureInfo.MINT_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)), 0);
}
require(vars.mathErr == MathError.NO_ERROR, "MINT_EXCHANGE_CALCULATION_FAILED");
require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_TOTAL_SUPPLY_CALCULATION_FAILED");
(vars.mathErr, vars.accountTokensNew) = addUInt(accountTokens[minter], vars.mintTokens);
require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED");
accountTokens[minter] = vars.accountTokensNew;
emit Transfer(address(this), minter, vars.mintTokens);
return (uint(Error.NO_ERROR), vars.actualMintAmount);
}
function mintFresh(address minter, uint mintAmount) internal returns (uint, uint) {
uint allowed = bController.mintAllowed(address(this), minter, mintAmount);
emit AllowedTestEvent(minter, address(this), allowed);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.MINT_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.MINT_FRESHNESS_CHECK), 0);
}
MintLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return (failOpaque(Error.MATH_ERROR, FailureInfo.MINT_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)), 0);
}
require(vars.mathErr == MathError.NO_ERROR, "MINT_EXCHANGE_CALCULATION_FAILED");
require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_TOTAL_SUPPLY_CALCULATION_FAILED");
(vars.mathErr, vars.accountTokensNew) = addUInt(accountTokens[minter], vars.mintTokens);
require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED");
accountTokens[minter] = vars.accountTokensNew;
emit Transfer(address(this), minter, vars.mintTokens);
return (uint(Error.NO_ERROR), vars.actualMintAmount);
}
vars.actualMintAmount = doTransferIn(minter, mintAmount);
(vars.mathErr, vars.mintTokens) = divScalarByExpTruncate(vars.actualMintAmount, Exp({mantissa: vars.exchangeRateMantissa}));
(vars.mathErr, vars.totalSupplyNew) = addUInt(totalSupply, vars.mintTokens);
totalSupply = vars.totalSupplyNew;
emit MintToken(minter, vars.actualMintAmount, vars.mintTokens);
bController.mintVerify(address(this), minter, vars.actualMintAmount, vars.mintTokens);
function redeemInternal(uint redeemTokens) internal nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED);
}
}
function redeemInternal(uint redeemTokens) internal nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED);
}
}
return redeemFresh(msg.sender, redeemTokens, 0);
function redeemUnderlyingInternal(uint redeemAmount) internal nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED);
}
}
function redeemUnderlyingInternal(uint redeemAmount) internal nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED);
}
}
return redeemFresh(msg.sender, 0, redeemAmount);
struct RedeemLocalVars {
Error err;
MathError mathErr;
uint exchangeRateMantissa;
uint redeemTokens;
uint redeemAmount;
uint totalSupplyNew;
uint accountTokensNew;
}
function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) {
require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
RedeemLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr));
}
if (redeemTokensIn > 0) {
vars.redeemTokens = redeemTokensIn;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr));
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr));
}
vars.redeemAmount = redeemAmountIn;
}
emit AllowedTestEvent(redeemer, address(this), allowed);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REDEEM_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
if (getCashPrior() < vars.redeemAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);
}
accountTokens[redeemer] = vars.accountTokensNew;
emit RedeemToken(redeemer, vars.redeemAmount, vars.redeemTokens);
return uint(Error.NO_ERROR);
}
function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) {
require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
RedeemLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr));
}
if (redeemTokensIn > 0) {
vars.redeemTokens = redeemTokensIn;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr));
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr));
}
vars.redeemAmount = redeemAmountIn;
}
emit AllowedTestEvent(redeemer, address(this), allowed);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REDEEM_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
if (getCashPrior() < vars.redeemAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);
}
accountTokens[redeemer] = vars.accountTokensNew;
emit RedeemToken(redeemer, vars.redeemAmount, vars.redeemTokens);
return uint(Error.NO_ERROR);
}
function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) {
require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
RedeemLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr));
}
if (redeemTokensIn > 0) {
vars.redeemTokens = redeemTokensIn;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr));
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr));
}
vars.redeemAmount = redeemAmountIn;
}
emit AllowedTestEvent(redeemer, address(this), allowed);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REDEEM_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
if (getCashPrior() < vars.redeemAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);
}
accountTokens[redeemer] = vars.accountTokensNew;
emit RedeemToken(redeemer, vars.redeemAmount, vars.redeemTokens);
return uint(Error.NO_ERROR);
}
(vars.mathErr, vars.redeemAmount) = mulScalarTruncate(Exp({mantissa: vars.exchangeRateMantissa}), redeemTokensIn);
function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) {
require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
RedeemLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr));
}
if (redeemTokensIn > 0) {
vars.redeemTokens = redeemTokensIn;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr));
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr));
}
vars.redeemAmount = redeemAmountIn;
}
emit AllowedTestEvent(redeemer, address(this), allowed);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REDEEM_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
if (getCashPrior() < vars.redeemAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);
}
accountTokens[redeemer] = vars.accountTokensNew;
emit RedeemToken(redeemer, vars.redeemAmount, vars.redeemTokens);
return uint(Error.NO_ERROR);
}
} else {
(vars.mathErr, vars.redeemTokens) = divScalarByExpTruncate(redeemAmountIn, Exp({mantissa: vars.exchangeRateMantissa}));
function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) {
require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
RedeemLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr));
}
if (redeemTokensIn > 0) {
vars.redeemTokens = redeemTokensIn;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr));
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr));
}
vars.redeemAmount = redeemAmountIn;
}
emit AllowedTestEvent(redeemer, address(this), allowed);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REDEEM_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
if (getCashPrior() < vars.redeemAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);
}
accountTokens[redeemer] = vars.accountTokensNew;
emit RedeemToken(redeemer, vars.redeemAmount, vars.redeemTokens);
return uint(Error.NO_ERROR);
}
uint allowed = bController.redeemAllowed(address(this), redeemer, vars.redeemTokens);
function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) {
require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
RedeemLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr));
}
if (redeemTokensIn > 0) {
vars.redeemTokens = redeemTokensIn;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr));
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr));
}
vars.redeemAmount = redeemAmountIn;
}
emit AllowedTestEvent(redeemer, address(this), allowed);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REDEEM_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
if (getCashPrior() < vars.redeemAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);
}
accountTokens[redeemer] = vars.accountTokensNew;
emit RedeemToken(redeemer, vars.redeemAmount, vars.redeemTokens);
return uint(Error.NO_ERROR);
}
function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) {
require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
RedeemLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr));
}
if (redeemTokensIn > 0) {
vars.redeemTokens = redeemTokensIn;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr));
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr));
}
vars.redeemAmount = redeemAmountIn;
}
emit AllowedTestEvent(redeemer, address(this), allowed);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REDEEM_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
if (getCashPrior() < vars.redeemAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);
}
accountTokens[redeemer] = vars.accountTokensNew;
emit RedeemToken(redeemer, vars.redeemAmount, vars.redeemTokens);
return uint(Error.NO_ERROR);
}
(vars.mathErr, vars.totalSupplyNew) = subUInt(totalSupply, vars.redeemTokens);
function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) {
require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
RedeemLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr));
}
if (redeemTokensIn > 0) {
vars.redeemTokens = redeemTokensIn;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr));
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr));
}
vars.redeemAmount = redeemAmountIn;
}
emit AllowedTestEvent(redeemer, address(this), allowed);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REDEEM_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
if (getCashPrior() < vars.redeemAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);
}
accountTokens[redeemer] = vars.accountTokensNew;
emit RedeemToken(redeemer, vars.redeemAmount, vars.redeemTokens);
return uint(Error.NO_ERROR);
}
function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) {
require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
RedeemLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr));
}
if (redeemTokensIn > 0) {
vars.redeemTokens = redeemTokensIn;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr));
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr));
}
vars.redeemAmount = redeemAmountIn;
}
emit AllowedTestEvent(redeemer, address(this), allowed);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REDEEM_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
if (getCashPrior() < vars.redeemAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);
}
accountTokens[redeemer] = vars.accountTokensNew;
emit RedeemToken(redeemer, vars.redeemAmount, vars.redeemTokens);
return uint(Error.NO_ERROR);
}
function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) {
require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero");
RedeemLocalVars memory vars;
(vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr));
}
if (redeemTokensIn > 0) {
vars.redeemTokens = redeemTokensIn;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr));
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr));
}
vars.redeemAmount = redeemAmountIn;
}
emit AllowedTestEvent(redeemer, address(this), allowed);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REDEEM_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);
}
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
if (getCashPrior() < vars.redeemAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);
}
accountTokens[redeemer] = vars.accountTokensNew;
emit RedeemToken(redeemer, vars.redeemAmount, vars.redeemTokens);
return uint(Error.NO_ERROR);
}
doTransferOut(redeemer, vars.redeemAmount);
totalSupply = vars.totalSupplyNew;
emit Transfer(redeemer, address(this), vars.redeemTokens);
bController.redeemVerify(address(this), redeemer, vars.redeemAmount, vars.redeemTokens);
function borrowInternal(uint borrowAmount) internal nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.BORROW_ACCRUE_INTEREST_FAILED);
}
}
function borrowInternal(uint borrowAmount) internal nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.BORROW_ACCRUE_INTEREST_FAILED);
}
}
return borrowFresh(msg.sender, borrowAmount);
struct BorrowLocalVars {
MathError mathErr;
uint accountBorrows;
uint accountBorrowsNew;
uint totalBorrowsNew;
}
function borrowFresh(address payable borrower, uint borrowAmount) internal returns (uint) {
uint allowed = bController.borrowAllowed(address(this), borrower, borrowAmount);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.BORROW_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.BORROW_FRESHNESS_CHECK);
}
if (getCashPrior() < borrowAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_CASH_NOT_AVAILABLE);
}
BorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountBorrowsNew) = addUInt(vars.accountBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.totalBorrowsNew) = addUInt(totalBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return uint(Error.NO_ERROR);
}
function borrowFresh(address payable borrower, uint borrowAmount) internal returns (uint) {
uint allowed = bController.borrowAllowed(address(this), borrower, borrowAmount);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.BORROW_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.BORROW_FRESHNESS_CHECK);
}
if (getCashPrior() < borrowAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_CASH_NOT_AVAILABLE);
}
BorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountBorrowsNew) = addUInt(vars.accountBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.totalBorrowsNew) = addUInt(totalBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return uint(Error.NO_ERROR);
}
function borrowFresh(address payable borrower, uint borrowAmount) internal returns (uint) {
uint allowed = bController.borrowAllowed(address(this), borrower, borrowAmount);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.BORROW_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.BORROW_FRESHNESS_CHECK);
}
if (getCashPrior() < borrowAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_CASH_NOT_AVAILABLE);
}
BorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountBorrowsNew) = addUInt(vars.accountBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.totalBorrowsNew) = addUInt(totalBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return uint(Error.NO_ERROR);
}
function borrowFresh(address payable borrower, uint borrowAmount) internal returns (uint) {
uint allowed = bController.borrowAllowed(address(this), borrower, borrowAmount);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.BORROW_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.BORROW_FRESHNESS_CHECK);
}
if (getCashPrior() < borrowAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_CASH_NOT_AVAILABLE);
}
BorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountBorrowsNew) = addUInt(vars.accountBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.totalBorrowsNew) = addUInt(totalBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return uint(Error.NO_ERROR);
}
(vars.mathErr, vars.accountBorrows) = borrowBalanceStoredInternal(borrower);
function borrowFresh(address payable borrower, uint borrowAmount) internal returns (uint) {
uint allowed = bController.borrowAllowed(address(this), borrower, borrowAmount);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.BORROW_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.BORROW_FRESHNESS_CHECK);
}
if (getCashPrior() < borrowAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_CASH_NOT_AVAILABLE);
}
BorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountBorrowsNew) = addUInt(vars.accountBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.totalBorrowsNew) = addUInt(totalBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return uint(Error.NO_ERROR);
}
function borrowFresh(address payable borrower, uint borrowAmount) internal returns (uint) {
uint allowed = bController.borrowAllowed(address(this), borrower, borrowAmount);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.BORROW_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.BORROW_FRESHNESS_CHECK);
}
if (getCashPrior() < borrowAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_CASH_NOT_AVAILABLE);
}
BorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountBorrowsNew) = addUInt(vars.accountBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.totalBorrowsNew) = addUInt(totalBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return uint(Error.NO_ERROR);
}
function borrowFresh(address payable borrower, uint borrowAmount) internal returns (uint) {
uint allowed = bController.borrowAllowed(address(this), borrower, borrowAmount);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.BORROW_BCONTROLLER_REJECTION, allowed);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.BORROW_FRESHNESS_CHECK);
}
if (getCashPrior() < borrowAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_CASH_NOT_AVAILABLE);
}
BorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.accountBorrowsNew) = addUInt(vars.accountBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
(vars.mathErr, vars.totalBorrowsNew) = addUInt(totalBorrows, borrowAmount);
if (vars.mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, uint(vars.mathErr));
}
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return uint(Error.NO_ERROR);
}
doTransferOut(borrower, borrowAmount);
accountBorrows[borrower].principal = vars.accountBorrowsNew;
emit BorrowToken(borrower, borrowAmount, vars.accountBorrowsNew, vars.totalBorrowsNew);
bController.borrowVerify(address(this), borrower, borrowAmount);
function repayBorrowInternal(uint repayAmount) internal nonReentrant returns (uint, uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.REPAY_BORROW_ACCRUE_INTEREST_FAILED), 0);
}
}
function repayBorrowInternal(uint repayAmount) internal nonReentrant returns (uint, uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.REPAY_BORROW_ACCRUE_INTEREST_FAILED), 0);
}
}
return repayBorrowFresh(msg.sender, msg.sender, repayAmount);
function repayBorrowBehalfInternal(address borrower, uint repayAmount) internal nonReentrant returns (uint, uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.REPAY_BEHALF_ACCRUE_INTEREST_FAILED), 0);
}
}
function repayBorrowBehalfInternal(address borrower, uint repayAmount) internal nonReentrant returns (uint, uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.REPAY_BEHALF_ACCRUE_INTEREST_FAILED), 0);
}
}
return repayBorrowFresh(msg.sender, borrower, repayAmount);
struct RepayBorrowLocalVars {
Error err;
MathError mathErr;
uint repayAmount;
uint borrowerIndex;
uint accountBorrows;
uint accountBorrowsNew;
uint totalBorrowsNew;
uint actualRepayAmount;
}
function repayBorrowFresh(address payer, address borrower, uint repayAmount) internal returns (uint, uint) {
uint allowed = bController.repayBorrowAllowed(address(this), payer, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REPAY_BORROW_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.REPAY_BORROW_FRESHNESS_CHECK), 0);
}
RepayBorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return (failOpaque(Error.MATH_ERROR, FailureInfo.REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)), 0);
}
if (repayAmount == uint(-1)) {
vars.repayAmount = vars.accountBorrows;
vars.repayAmount = repayAmount;
}
require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED");
(vars.mathErr, vars.totalBorrowsNew) = subUInt(totalBorrows, vars.actualRepayAmount);
require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED");
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return (uint(Error.NO_ERROR), vars.actualRepayAmount);
}
function repayBorrowFresh(address payer, address borrower, uint repayAmount) internal returns (uint, uint) {
uint allowed = bController.repayBorrowAllowed(address(this), payer, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REPAY_BORROW_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.REPAY_BORROW_FRESHNESS_CHECK), 0);
}
RepayBorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return (failOpaque(Error.MATH_ERROR, FailureInfo.REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)), 0);
}
if (repayAmount == uint(-1)) {
vars.repayAmount = vars.accountBorrows;
vars.repayAmount = repayAmount;
}
require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED");
(vars.mathErr, vars.totalBorrowsNew) = subUInt(totalBorrows, vars.actualRepayAmount);
require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED");
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return (uint(Error.NO_ERROR), vars.actualRepayAmount);
}
function repayBorrowFresh(address payer, address borrower, uint repayAmount) internal returns (uint, uint) {
uint allowed = bController.repayBorrowAllowed(address(this), payer, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REPAY_BORROW_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.REPAY_BORROW_FRESHNESS_CHECK), 0);
}
RepayBorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return (failOpaque(Error.MATH_ERROR, FailureInfo.REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)), 0);
}
if (repayAmount == uint(-1)) {
vars.repayAmount = vars.accountBorrows;
vars.repayAmount = repayAmount;
}
require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED");
(vars.mathErr, vars.totalBorrowsNew) = subUInt(totalBorrows, vars.actualRepayAmount);
require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED");
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return (uint(Error.NO_ERROR), vars.actualRepayAmount);
}
vars.borrowerIndex = accountBorrows[borrower].interestIndex;
(vars.mathErr, vars.accountBorrows) = borrowBalanceStoredInternal(borrower);
function repayBorrowFresh(address payer, address borrower, uint repayAmount) internal returns (uint, uint) {
uint allowed = bController.repayBorrowAllowed(address(this), payer, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REPAY_BORROW_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.REPAY_BORROW_FRESHNESS_CHECK), 0);
}
RepayBorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return (failOpaque(Error.MATH_ERROR, FailureInfo.REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)), 0);
}
if (repayAmount == uint(-1)) {
vars.repayAmount = vars.accountBorrows;
vars.repayAmount = repayAmount;
}
require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED");
(vars.mathErr, vars.totalBorrowsNew) = subUInt(totalBorrows, vars.actualRepayAmount);
require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED");
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return (uint(Error.NO_ERROR), vars.actualRepayAmount);
}
function repayBorrowFresh(address payer, address borrower, uint repayAmount) internal returns (uint, uint) {
uint allowed = bController.repayBorrowAllowed(address(this), payer, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.REPAY_BORROW_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.REPAY_BORROW_FRESHNESS_CHECK), 0);
}
RepayBorrowLocalVars memory vars;
if (vars.mathErr != MathError.NO_ERROR) {
return (failOpaque(Error.MATH_ERROR, FailureInfo.REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)), 0);
}
if (repayAmount == uint(-1)) {
vars.repayAmount = vars.accountBorrows;
vars.repayAmount = repayAmount;
}
require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED");
(vars.mathErr, vars.totalBorrowsNew) = subUInt(totalBorrows, vars.actualRepayAmount);
require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED");
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = vars.totalBorrowsNew;
return (uint(Error.NO_ERROR), vars.actualRepayAmount);
}
} else {
vars.actualRepayAmount = doTransferIn(payer, vars.repayAmount);
(vars.mathErr, vars.accountBorrowsNew) = subUInt(vars.accountBorrows, vars.actualRepayAmount);
accountBorrows[borrower].principal = vars.accountBorrowsNew;
emit RepayBorrowToken(payer, borrower, vars.actualRepayAmount, vars.accountBorrowsNew, vars.totalBorrowsNew);
bController.repayBorrowVerify(address(this), payer, borrower, vars.actualRepayAmount, vars.borrowerIndex);
function liquidateBorrowInternal(address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal nonReentrant returns (uint, uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED), 0);
}
error = bTokenCollateral.accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED), 0);
}
}
function liquidateBorrowInternal(address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal nonReentrant returns (uint, uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED), 0);
}
error = bTokenCollateral.accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED), 0);
}
}
function liquidateBorrowInternal(address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal nonReentrant returns (uint, uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED), 0);
}
error = bTokenCollateral.accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED), 0);
}
}
return liquidateBorrowFresh(msg.sender, borrower, repayAmount, bTokenCollateral);
function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal returns (uint, uint) {
uint allowed = bController.liquidateBorrowAllowed(address(this), address(bTokenCollateral), liquidator, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);
}
if (bTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);
}
if (borrower == liquidator) {
return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);
}
if (repayAmount == 0) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);
}
if (repayAmount == uint(-1)) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);
}
if (repayBorrowError != uint(Error.NO_ERROR)) {
return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);
}
require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_BCONTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
if (address(bTokenCollateral) == address(this)) {
seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);
seizeError = bTokenCollateral.seize(liquidator, borrower, seizeTokens);
}
return (uint(Error.NO_ERROR), actualRepayAmount);
}
function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal returns (uint, uint) {
uint allowed = bController.liquidateBorrowAllowed(address(this), address(bTokenCollateral), liquidator, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);
}
if (bTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);
}
if (borrower == liquidator) {
return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);
}
if (repayAmount == 0) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);
}
if (repayAmount == uint(-1)) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);
}
if (repayBorrowError != uint(Error.NO_ERROR)) {
return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);
}
require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_BCONTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
if (address(bTokenCollateral) == address(this)) {
seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);
seizeError = bTokenCollateral.seize(liquidator, borrower, seizeTokens);
}
return (uint(Error.NO_ERROR), actualRepayAmount);
}
function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal returns (uint, uint) {
uint allowed = bController.liquidateBorrowAllowed(address(this), address(bTokenCollateral), liquidator, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);
}
if (bTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);
}
if (borrower == liquidator) {
return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);
}
if (repayAmount == 0) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);
}
if (repayAmount == uint(-1)) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);
}
if (repayBorrowError != uint(Error.NO_ERROR)) {
return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);
}
require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_BCONTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
if (address(bTokenCollateral) == address(this)) {
seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);
seizeError = bTokenCollateral.seize(liquidator, borrower, seizeTokens);
}
return (uint(Error.NO_ERROR), actualRepayAmount);
}
function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal returns (uint, uint) {
uint allowed = bController.liquidateBorrowAllowed(address(this), address(bTokenCollateral), liquidator, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);
}
if (bTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);
}
if (borrower == liquidator) {
return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);
}
if (repayAmount == 0) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);
}
if (repayAmount == uint(-1)) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);
}
if (repayBorrowError != uint(Error.NO_ERROR)) {
return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);
}
require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_BCONTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
if (address(bTokenCollateral) == address(this)) {
seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);
seizeError = bTokenCollateral.seize(liquidator, borrower, seizeTokens);
}
return (uint(Error.NO_ERROR), actualRepayAmount);
}
function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal returns (uint, uint) {
uint allowed = bController.liquidateBorrowAllowed(address(this), address(bTokenCollateral), liquidator, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);
}
if (bTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);
}
if (borrower == liquidator) {
return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);
}
if (repayAmount == 0) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);
}
if (repayAmount == uint(-1)) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);
}
if (repayBorrowError != uint(Error.NO_ERROR)) {
return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);
}
require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_BCONTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
if (address(bTokenCollateral) == address(this)) {
seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);
seizeError = bTokenCollateral.seize(liquidator, borrower, seizeTokens);
}
return (uint(Error.NO_ERROR), actualRepayAmount);
}
function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal returns (uint, uint) {
uint allowed = bController.liquidateBorrowAllowed(address(this), address(bTokenCollateral), liquidator, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);
}
if (bTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);
}
if (borrower == liquidator) {
return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);
}
if (repayAmount == 0) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);
}
if (repayAmount == uint(-1)) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);
}
if (repayBorrowError != uint(Error.NO_ERROR)) {
return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);
}
require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_BCONTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
if (address(bTokenCollateral) == address(this)) {
seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);
seizeError = bTokenCollateral.seize(liquidator, borrower, seizeTokens);
}
return (uint(Error.NO_ERROR), actualRepayAmount);
}
function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal returns (uint, uint) {
uint allowed = bController.liquidateBorrowAllowed(address(this), address(bTokenCollateral), liquidator, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);
}
if (bTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);
}
if (borrower == liquidator) {
return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);
}
if (repayAmount == 0) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);
}
if (repayAmount == uint(-1)) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);
}
if (repayBorrowError != uint(Error.NO_ERROR)) {
return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);
}
require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_BCONTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
if (address(bTokenCollateral) == address(this)) {
seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);
seizeError = bTokenCollateral.seize(liquidator, borrower, seizeTokens);
}
return (uint(Error.NO_ERROR), actualRepayAmount);
}
(uint repayBorrowError, uint actualRepayAmount) = repayBorrowFresh(liquidator, borrower, repayAmount);
function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal returns (uint, uint) {
uint allowed = bController.liquidateBorrowAllowed(address(this), address(bTokenCollateral), liquidator, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);
}
if (bTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);
}
if (borrower == liquidator) {
return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);
}
if (repayAmount == 0) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);
}
if (repayAmount == uint(-1)) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);
}
if (repayBorrowError != uint(Error.NO_ERROR)) {
return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);
}
require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_BCONTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
if (address(bTokenCollateral) == address(this)) {
seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);
seizeError = bTokenCollateral.seize(liquidator, borrower, seizeTokens);
}
return (uint(Error.NO_ERROR), actualRepayAmount);
}
(uint amountSeizeError, uint seizeTokens) = bController.liquidateCalculateSeizeTokens(address(this), address(bTokenCollateral), actualRepayAmount);
require(bTokenCollateral.balanceOf(borrower) >= seizeTokens, "LIQUIDATE_SEIZE_TOO_MUCH");
uint seizeError;
function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, BTokenInterface bTokenCollateral) internal returns (uint, uint) {
uint allowed = bController.liquidateBorrowAllowed(address(this), address(bTokenCollateral), liquidator, borrower, repayAmount);
if (allowed != 0) {
return (failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_BCONTROLLER_REJECTION, allowed), 0);
}
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);
}
if (bTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);
}
if (borrower == liquidator) {
return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);
}
if (repayAmount == 0) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);
}
if (repayAmount == uint(-1)) {
return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);
}
if (repayBorrowError != uint(Error.NO_ERROR)) {
return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);
}
require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_BCONTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED");
if (address(bTokenCollateral) == address(this)) {
seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);
seizeError = bTokenCollateral.seize(liquidator, borrower, seizeTokens);
}
return (uint(Error.NO_ERROR), actualRepayAmount);
}
} else {
require(seizeError == uint(Error.NO_ERROR), "token seizure failed");
emit LiquidateBorrowToken(liquidator, borrower, actualRepayAmount, address(bTokenCollateral), seizeTokens);
bController.liquidateBorrowVerify(address(this), address(bTokenCollateral), liquidator, borrower, actualRepayAmount, seizeTokens);
function seize(address liquidator, address borrower, uint seizeTokens) external nonReentrant returns (uint) {
return seizeInternal(msg.sender, liquidator, borrower, seizeTokens);
}
function seizeInternal(address seizerToken, address liquidator, address borrower, uint seizeTokens) internal returns (uint) {
uint allowed = bController.seizeAllowed(address(this), seizerToken, liquidator, borrower, seizeTokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_SEIZE_BCONTROLLER_REJECTION, allowed);
}
if (borrower == liquidator) {
return fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER);
}
MathError mathErr;
uint borrowerTokensNew;
uint liquidatorTokensNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED, uint(mathErr));
}
(mathErr, liquidatorTokensNew) = addUInt(accountTokens[liquidator], seizeTokens);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED, uint(mathErr));
}
accountTokens[liquidator] = liquidatorTokensNew;
return uint(Error.NO_ERROR);
}
function seizeInternal(address seizerToken, address liquidator, address borrower, uint seizeTokens) internal returns (uint) {
uint allowed = bController.seizeAllowed(address(this), seizerToken, liquidator, borrower, seizeTokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_SEIZE_BCONTROLLER_REJECTION, allowed);
}
if (borrower == liquidator) {
return fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER);
}
MathError mathErr;
uint borrowerTokensNew;
uint liquidatorTokensNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED, uint(mathErr));
}
(mathErr, liquidatorTokensNew) = addUInt(accountTokens[liquidator], seizeTokens);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED, uint(mathErr));
}
accountTokens[liquidator] = liquidatorTokensNew;
return uint(Error.NO_ERROR);
}
function seizeInternal(address seizerToken, address liquidator, address borrower, uint seizeTokens) internal returns (uint) {
uint allowed = bController.seizeAllowed(address(this), seizerToken, liquidator, borrower, seizeTokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_SEIZE_BCONTROLLER_REJECTION, allowed);
}
if (borrower == liquidator) {
return fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER);
}
MathError mathErr;
uint borrowerTokensNew;
uint liquidatorTokensNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED, uint(mathErr));
}
(mathErr, liquidatorTokensNew) = addUInt(accountTokens[liquidator], seizeTokens);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED, uint(mathErr));
}
accountTokens[liquidator] = liquidatorTokensNew;
return uint(Error.NO_ERROR);
}
(mathErr, borrowerTokensNew) = subUInt(accountTokens[borrower], seizeTokens);
function seizeInternal(address seizerToken, address liquidator, address borrower, uint seizeTokens) internal returns (uint) {
uint allowed = bController.seizeAllowed(address(this), seizerToken, liquidator, borrower, seizeTokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_SEIZE_BCONTROLLER_REJECTION, allowed);
}
if (borrower == liquidator) {
return fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER);
}
MathError mathErr;
uint borrowerTokensNew;
uint liquidatorTokensNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED, uint(mathErr));
}
(mathErr, liquidatorTokensNew) = addUInt(accountTokens[liquidator], seizeTokens);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED, uint(mathErr));
}
accountTokens[liquidator] = liquidatorTokensNew;
return uint(Error.NO_ERROR);
}
function seizeInternal(address seizerToken, address liquidator, address borrower, uint seizeTokens) internal returns (uint) {
uint allowed = bController.seizeAllowed(address(this), seizerToken, liquidator, borrower, seizeTokens);
if (allowed != 0) {
return failOpaque(Error.BCONTROLLER_REJECTION, FailureInfo.LIQUIDATE_SEIZE_BCONTROLLER_REJECTION, allowed);
}
if (borrower == liquidator) {
return fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER);
}
MathError mathErr;
uint borrowerTokensNew;
uint liquidatorTokensNew;
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED, uint(mathErr));
}
(mathErr, liquidatorTokensNew) = addUInt(accountTokens[liquidator], seizeTokens);
if (mathErr != MathError.NO_ERROR) {
return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED, uint(mathErr));
}
accountTokens[liquidator] = liquidatorTokensNew;
return uint(Error.NO_ERROR);
}
accountTokens[borrower] = borrowerTokensNew;
emit Transfer(borrower, liquidator, seizeTokens);
bController.seizeVerify(address(this), seizerToken, liquidator, borrower, seizeTokens);
function _setPendingAdmin(address payable newPendingAdmin) external returns (uint) {
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_ADMIN_OWNER_CHECK);
}
return uint(Error.NO_ERROR);
}
function _setPendingAdmin(address payable newPendingAdmin) external returns (uint) {
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_ADMIN_OWNER_CHECK);
}
return uint(Error.NO_ERROR);
}
address oldPendingAdmin = pendingAdmin;
pendingAdmin = newPendingAdmin;
emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);
function _acceptAdmin() external returns (uint) {
if (msg.sender != pendingAdmin || msg.sender == address(0)) {
return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK);
}
address oldPendingAdmin = pendingAdmin;
emit NewAdmin(oldAdmin, admin);
emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);
return uint(Error.NO_ERROR);
}
function _acceptAdmin() external returns (uint) {
if (msg.sender != pendingAdmin || msg.sender == address(0)) {
return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK);
}
address oldPendingAdmin = pendingAdmin;
emit NewAdmin(oldAdmin, admin);
emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);
return uint(Error.NO_ERROR);
}
address oldAdmin = admin;
admin = pendingAdmin;
pendingAdmin = address(0);
function _setBController(BControllerInterface newBController) public returns (uint) {
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_BCONTROLLER_OWNER_CHECK);
}
BControllerInterface oldBController = bController;
return uint(Error.NO_ERROR);
}
function _setBController(BControllerInterface newBController) public returns (uint) {
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_BCONTROLLER_OWNER_CHECK);
}
BControllerInterface oldBController = bController;
return uint(Error.NO_ERROR);
}
require(newBController.isBController(), "marker method returned false");
bController = newBController;
emit NewBController(oldBController, newBController);
function _setReserveFactor(uint newReserveFactorMantissa) external nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.SET_RESERVE_FACTOR_ACCRUE_INTEREST_FAILED);
}
}
function _setReserveFactor(uint newReserveFactorMantissa) external nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.SET_RESERVE_FACTOR_ACCRUE_INTEREST_FAILED);
}
}
return _setReserveFactorFresh(newReserveFactorMantissa);
function _setReserveFactorFresh(uint newReserveFactorMantissa) internal returns (uint) {
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_RESERVE_FACTOR_ADMIN_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_RESERVE_FACTOR_FRESH_CHECK);
}
if (newReserveFactorMantissa > reserveFactorMaxMantissa) {
return fail(Error.BAD_INPUT, FailureInfo.SET_RESERVE_FACTOR_BOUNDS_CHECK);
}
uint oldReserveFactorMantissa = reserveFactorMantissa;
reserveFactorMantissa = newReserveFactorMantissa;
emit NewTokenReserveFactor(oldReserveFactorMantissa, newReserveFactorMantissa);
return uint(Error.NO_ERROR);
}
function _setReserveFactorFresh(uint newReserveFactorMantissa) internal returns (uint) {
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_RESERVE_FACTOR_ADMIN_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_RESERVE_FACTOR_FRESH_CHECK);
}
if (newReserveFactorMantissa > reserveFactorMaxMantissa) {
return fail(Error.BAD_INPUT, FailureInfo.SET_RESERVE_FACTOR_BOUNDS_CHECK);
}
uint oldReserveFactorMantissa = reserveFactorMantissa;
reserveFactorMantissa = newReserveFactorMantissa;
emit NewTokenReserveFactor(oldReserveFactorMantissa, newReserveFactorMantissa);
return uint(Error.NO_ERROR);
}
function _setReserveFactorFresh(uint newReserveFactorMantissa) internal returns (uint) {
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_RESERVE_FACTOR_ADMIN_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_RESERVE_FACTOR_FRESH_CHECK);
}
if (newReserveFactorMantissa > reserveFactorMaxMantissa) {
return fail(Error.BAD_INPUT, FailureInfo.SET_RESERVE_FACTOR_BOUNDS_CHECK);
}
uint oldReserveFactorMantissa = reserveFactorMantissa;
reserveFactorMantissa = newReserveFactorMantissa;
emit NewTokenReserveFactor(oldReserveFactorMantissa, newReserveFactorMantissa);
return uint(Error.NO_ERROR);
}
function _setReserveFactorFresh(uint newReserveFactorMantissa) internal returns (uint) {
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_RESERVE_FACTOR_ADMIN_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_RESERVE_FACTOR_FRESH_CHECK);
}
if (newReserveFactorMantissa > reserveFactorMaxMantissa) {
return fail(Error.BAD_INPUT, FailureInfo.SET_RESERVE_FACTOR_BOUNDS_CHECK);
}
uint oldReserveFactorMantissa = reserveFactorMantissa;
reserveFactorMantissa = newReserveFactorMantissa;
emit NewTokenReserveFactor(oldReserveFactorMantissa, newReserveFactorMantissa);
return uint(Error.NO_ERROR);
}
function _addReservesInternal(uint addAmount) internal nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.ADD_RESERVES_ACCRUE_INTEREST_FAILED);
}
return error;
}
function _addReservesInternal(uint addAmount) internal nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.ADD_RESERVES_ACCRUE_INTEREST_FAILED);
}
return error;
}
(error, ) = _addReservesFresh(addAmount);
function _addReservesFresh(uint addAmount) internal returns (uint, uint) {
uint totalReservesNew;
uint actualAddAmount;
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.ADD_RESERVES_FRESH_CHECK), actualAddAmount);
}
actualAddAmount = doTransferIn(msg.sender, addAmount);
totalReservesNew = totalReserves + actualAddAmount;
}
function _addReservesFresh(uint addAmount) internal returns (uint, uint) {
uint totalReservesNew;
uint actualAddAmount;
if (accrualBlockNumber != getBlockNumber()) {
return (fail(Error.MARKET_NOT_FRESH, FailureInfo.ADD_RESERVES_FRESH_CHECK), actualAddAmount);
}
actualAddAmount = doTransferIn(msg.sender, addAmount);
totalReservesNew = totalReserves + actualAddAmount;
}
require(totalReservesNew >= totalReserves, "add reserves unexpected overflow");
totalReserves = totalReservesNew;
emit ReservesAdded(msg.sender, actualAddAmount, totalReservesNew);
return (uint(Error.NO_ERROR), actualAddAmount);
function _reduceReserves(uint reduceAmount) external nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.REDUCE_RESERVES_ACCRUE_INTEREST_FAILED);
}
}
function _reduceReserves(uint reduceAmount) external nonReentrant returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.REDUCE_RESERVES_ACCRUE_INTEREST_FAILED);
}
}
return _reduceReservesFresh(reduceAmount);
function _reduceReservesFresh(uint reduceAmount) internal returns (uint) {
uint totalReservesNew;
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.REDUCE_RESERVES_ADMIN_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDUCE_RESERVES_FRESH_CHECK);
}
if (getCashPrior() < reduceAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDUCE_RESERVES_CASH_NOT_AVAILABLE);
}
if (reduceAmount > totalReserves) {
return fail(Error.BAD_INPUT, FailureInfo.REDUCE_RESERVES_VALIDATION);
}
totalReservesNew = totalReserves - reduceAmount;
emit ReservesReduced(admin, reduceAmount, totalReservesNew);
return uint(Error.NO_ERROR);
}
function _reduceReservesFresh(uint reduceAmount) internal returns (uint) {
uint totalReservesNew;
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.REDUCE_RESERVES_ADMIN_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDUCE_RESERVES_FRESH_CHECK);
}
if (getCashPrior() < reduceAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDUCE_RESERVES_CASH_NOT_AVAILABLE);
}
if (reduceAmount > totalReserves) {
return fail(Error.BAD_INPUT, FailureInfo.REDUCE_RESERVES_VALIDATION);
}
totalReservesNew = totalReserves - reduceAmount;
emit ReservesReduced(admin, reduceAmount, totalReservesNew);
return uint(Error.NO_ERROR);
}
function _reduceReservesFresh(uint reduceAmount) internal returns (uint) {
uint totalReservesNew;
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.REDUCE_RESERVES_ADMIN_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDUCE_RESERVES_FRESH_CHECK);
}
if (getCashPrior() < reduceAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDUCE_RESERVES_CASH_NOT_AVAILABLE);
}
if (reduceAmount > totalReserves) {
return fail(Error.BAD_INPUT, FailureInfo.REDUCE_RESERVES_VALIDATION);
}
totalReservesNew = totalReserves - reduceAmount;
emit ReservesReduced(admin, reduceAmount, totalReservesNew);
return uint(Error.NO_ERROR);
}
function _reduceReservesFresh(uint reduceAmount) internal returns (uint) {
uint totalReservesNew;
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.REDUCE_RESERVES_ADMIN_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDUCE_RESERVES_FRESH_CHECK);
}
if (getCashPrior() < reduceAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDUCE_RESERVES_CASH_NOT_AVAILABLE);
}
if (reduceAmount > totalReserves) {
return fail(Error.BAD_INPUT, FailureInfo.REDUCE_RESERVES_VALIDATION);
}
totalReservesNew = totalReserves - reduceAmount;
emit ReservesReduced(admin, reduceAmount, totalReservesNew);
return uint(Error.NO_ERROR);
}
function _reduceReservesFresh(uint reduceAmount) internal returns (uint) {
uint totalReservesNew;
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.REDUCE_RESERVES_ADMIN_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDUCE_RESERVES_FRESH_CHECK);
}
if (getCashPrior() < reduceAmount) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDUCE_RESERVES_CASH_NOT_AVAILABLE);
}
if (reduceAmount > totalReserves) {
return fail(Error.BAD_INPUT, FailureInfo.REDUCE_RESERVES_VALIDATION);
}
totalReservesNew = totalReserves - reduceAmount;
emit ReservesReduced(admin, reduceAmount, totalReservesNew);
return uint(Error.NO_ERROR);
}
require(totalReservesNew <= totalReserves, "reduce reserves unexpected underflow");
totalReserves = totalReservesNew;
doTransferOut(admin, reduceAmount);
function _setInterestRateModel(InterestRateModel newInterestRateModel) public returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.SET_INTEREST_RATE_MODEL_ACCRUE_INTEREST_FAILED);
}
}
function _setInterestRateModel(InterestRateModel newInterestRateModel) public returns (uint) {
uint error = accrueInterest();
if (error != uint(Error.NO_ERROR)) {
return fail(Error(error), FailureInfo.SET_INTEREST_RATE_MODEL_ACCRUE_INTEREST_FAILED);
}
}
return _setInterestRateModelFresh(newInterestRateModel);
function _setInterestRateModelFresh(InterestRateModel newInterestRateModel) internal returns (uint) {
InterestRateModel oldInterestRateModel;
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_INTEREST_RATE_MODEL_OWNER_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_INTEREST_RATE_MODEL_FRESH_CHECK);
}
return uint(Error.NO_ERROR);
}
function _setInterestRateModelFresh(InterestRateModel newInterestRateModel) internal returns (uint) {
InterestRateModel oldInterestRateModel;
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_INTEREST_RATE_MODEL_OWNER_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_INTEREST_RATE_MODEL_FRESH_CHECK);
}
return uint(Error.NO_ERROR);
}
function _setInterestRateModelFresh(InterestRateModel newInterestRateModel) internal returns (uint) {
InterestRateModel oldInterestRateModel;
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SET_INTEREST_RATE_MODEL_OWNER_CHECK);
}
if (accrualBlockNumber != getBlockNumber()) {
return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_INTEREST_RATE_MODEL_FRESH_CHECK);
}
return uint(Error.NO_ERROR);
}
oldInterestRateModel = interestRateModel;
require(newInterestRateModel.isInterestRateModel(), "marker method returned false");
interestRateModel = newInterestRateModel;
emit NewMarketTokenInterestRateModel(oldInterestRateModel, newInterestRateModel);
function getCashPrior() internal view returns (uint);
function doTransferIn(address from, uint amount) internal returns (uint);
function doTransferOut(address payable to, uint amount) internal;
modifier nonReentrant() {
require(_notEntered, "re-entered");
_notEntered = false;
_;
}
}
| 8,918,138 | [
1,
38,
6909,
1807,
605,
1345,
13456,
225,
4115,
1026,
364,
605,
5157,
19,
7769,
871,
358,
866,
4121,
353,
21311,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
605,
1345,
353,
605,
1345,
1358,
16,
29770,
649,
16,
3155,
668,
13289,
288,
203,
203,
565,
871,
16740,
4709,
1133,
12,
2867,
8808,
729,
16,
1758,
8808,
324,
1345,
16,
2254,
5034,
12079,
1769,
203,
203,
565,
445,
4046,
12,
38,
2933,
1358,
324,
2933,
67,
16,
203,
13491,
5294,
395,
4727,
1488,
16513,
4727,
1488,
67,
16,
203,
13491,
2254,
2172,
11688,
4727,
49,
970,
21269,
67,
16,
203,
13491,
533,
3778,
508,
67,
16,
203,
13491,
533,
3778,
3273,
67,
16,
203,
97,
203,
13491,
2254,
28,
15105,
67,
13,
1071,
288,
203,
3639,
2583,
12,
3576,
18,
15330,
422,
3981,
16,
315,
3700,
3981,
2026,
4046,
326,
13667,
8863,
203,
3639,
2583,
12,
8981,
86,
1462,
1768,
1854,
422,
374,
597,
29759,
1016,
422,
374,
16,
315,
27151,
2026,
1338,
506,
6454,
3647,
8863,
203,
203,
3639,
2172,
11688,
4727,
49,
970,
21269,
273,
2172,
11688,
4727,
49,
970,
21269,
67,
31,
203,
3639,
2583,
12,
6769,
11688,
4727,
49,
970,
21269,
405,
374,
16,
315,
6769,
7829,
4993,
1297,
506,
6802,
2353,
3634,
1199,
1769,
203,
203,
3639,
2254,
393,
273,
389,
542,
38,
2933,
12,
70,
2933,
67,
1769,
203,
3639,
2583,
12,
370,
422,
2254,
12,
668,
18,
3417,
67,
3589,
3631,
315,
8920,
324,
2933,
2535,
8863,
203,
203,
3639,
4078,
86,
1462,
1768,
1854,
273,
11902,
1854,
5621,
203,
3639,
29759,
1016,
273,
31340,
3335,
31,
203,
203,
3639,
393,
273,
389,
542,
29281,
4727,
1488,
42,
1955,
12,
2761,
395,
4727,
1488,
67,
2
] |
// Based on https://github.com/HausDAO/Molochv2.1
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
// import "hardhat/console.sol";
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Moloch is ReentrancyGuard {
/***************
GLOBAL CONSTANTS
***************/
uint256 public periodDuration; // default = 17280 = 4.8 hours in seconds (5 periods per day)
uint256 public votingPeriodLength; // default = 35 periods (7 days)
uint256 public gracePeriodLength; // default = 35 periods (7 days)
uint256 public proposalDeposit; // default = 10 ETH (~$1,000 worth of ETH at contract deployment)
uint256 public dilutionBound; // default = 3 - maximum multiplier a YES voter will be obligated to pay in case of mass ragequit
uint256 public processingReward; // default = 0.1 - amount of ETH to give to whoever processes a proposal
uint256 public summoningTime; // needed to determine the current period
bool private initialized; // internally tracks deployment under eip-1167 proxy pattern
address public depositToken; // deposit token contract reference; default = wETH
uint256 public spamPrevention;
address public spamPreventionAddr;
// can have multiple shamans
mapping(address => bool) public shamans;
// HARD-CODED LIMITS
// These numbers are quite arbitrary; they are small enough to avoid overflows when doing calculations
// with periods or shares, yet big enough to not limit reasonable use cases.
uint256 constant MAX_VOTING_PERIOD_LENGTH = 10**18; // maximum length of voting period
uint256 constant MAX_GRACE_PERIOD_LENGTH = 10**18; // maximum length of grace period
uint256 constant MAX_DILUTION_BOUND = 10**18; // maximum dilution bound
uint256 constant MAX_NUMBER_OF_SHARES_AND_LOOT = 10**18; // maximum number of shares that can be minted
uint256 constant MAX_TOKEN_WHITELIST_COUNT = 400; // maximum number of whitelisted tokens
uint256 constant MAX_TOKEN_GUILDBANK_COUNT = 200; // maximum number of tokens with non-zero balance in guildbank
// ***************
// EVENTS
// ***************
event SummonComplete(
address indexed summoner,
address[] tokens,
uint256 summoningTime,
uint256 periodDuration,
uint256 votingPeriodLength,
uint256 gracePeriodLength,
uint256 proposalDeposit,
uint256 dilutionBound,
uint256 processingReward
);
event SubmitProposal(
address indexed applicant,
uint256 sharesRequested,
uint256 lootRequested,
uint256 tributeOffered,
address tributeToken,
uint256 paymentRequested,
address paymentToken,
string details,
bool[6] flags,
uint256 proposalId,
address indexed delegateKey,
address indexed memberAddress
);
event SponsorProposal(
address indexed delegateKey,
address indexed memberAddress,
uint256 proposalId,
uint256 proposalIndex,
uint256 startingPeriod
);
event SubmitVote(
uint256 proposalId,
uint256 indexed proposalIndex,
address indexed delegateKey,
address indexed memberAddress,
uint8 uintVote
);
event ProcessProposal(
uint256 indexed proposalIndex,
uint256 indexed proposalId,
bool didPass
);
event ProcessWhitelistProposal(
uint256 indexed proposalIndex,
uint256 indexed proposalId,
bool didPass
);
event ProcessGuildKickProposal(
uint256 indexed proposalIndex,
uint256 indexed proposalId,
bool didPass
);
event Ragequit(
address indexed memberAddress,
uint256 sharesToBurn,
uint256 lootToBurn
);
event TokensCollected(address indexed token, uint256 amountToCollect);
event CancelProposal(uint256 indexed proposalId, address applicantAddress);
event UpdateDelegateKey(
address indexed memberAddress,
address newDelegateKey
);
event Withdraw(
address indexed memberAddress,
address token,
uint256 amount
);
event Shaman(
address indexed memberAddress,
uint256 shares,
uint256 loot,
bool mint
);
event SetSpamPrevention(address spamPreventionAddr, uint256 spamPrevention);
event SetShaman(address indexed shaman, bool isEnabled);
event SetConfig(
uint256 periodDuration,
uint256 votingPeriodLength,
uint256 gracePeriodLength,
uint256 proposalDeposit,
uint256 dilutionBound,
uint256 processingReward
);
// *******************
// INTERNAL ACCOUNTING
// *******************
uint256 public proposalCount = 0; // total proposals submitted
uint256 public totalShares = 0; // total shares across all members
uint256 public totalLoot = 0; // total loot across all members
uint256 public totalGuildBankTokens = 0; // total tokens with non-zero balance in guild bank
address public constant GUILD = address(0xdead);
address public constant ESCROW = address(0xbeef);
address public constant TOTAL = address(0xbabe);
mapping(address => mapping(address => uint256)) public userTokenBalances; // userTokenBalances[userAddress][tokenAddress]
enum Vote {
Null, // default value, counted as abstention
Yes,
No
}
struct Member {
address delegateKey; // the key responsible for submitting proposals and voting - defaults to member address unless updated
uint256 shares; // the # of voting shares assigned to this member
uint256 loot; // the loot amount available to this member (combined with shares on ragequit)
bool exists; // always true once a member has been created
uint256 highestIndexYesVote; // highest proposal index # on which the member voted YES
uint256 jailed; // set to proposalIndex of a passing guild kick proposal for this member, prevents voting on and sponsoring proposals
}
struct Proposal {
address applicant; // the applicant who wishes to become a member - this key will be used for withdrawals (doubles as guild kick target for gkick proposals)
address proposer; // the account that submitted the proposal (can be non-member)
address sponsor; // the member that sponsored the proposal (moving it into the queue)
uint256 sharesRequested; // the # of shares the applicant is requesting
uint256 lootRequested; // the amount of loot the applicant is requesting
uint256 tributeOffered; // amount of tokens offered as tribute
address tributeToken; // tribute token contract reference
uint256 paymentRequested; // amount of tokens requested as payment
address paymentToken; // payment token contract reference
uint256 startingPeriod; // the period in which voting can start for this proposal
uint256 yesVotes; // the total number of YES votes for this proposal
uint256 noVotes; // the total number of NO votes for this proposal
bool[6] flags; // [sponsored, processed, didPass, cancelled, whitelist, guildkick]
string details; // proposal details - could be IPFS hash, plaintext, or JSON
uint256 maxTotalSharesAndLootAtYesVote; // the maximum # of total shares encountered at a yes vote on this proposal
}
mapping(uint256 => mapping(address => Vote)) voteHistory; // maps voting decisions on proposals proposal => member => voted
mapping(address => bool) public tokenWhitelist;
address[] public approvedTokens;
mapping(address => bool) public proposedToWhitelist;
mapping(address => bool) public proposedToKick;
mapping(address => Member) public members;
mapping(address => address) public memberAddressByDelegateKey;
// TODO: whats this for?
address[] public memberList;
mapping(uint256 => Proposal) public proposals;
uint256[] public proposalQueue;
modifier onlyMember() {
require(
members[msg.sender].shares > 0 || members[msg.sender].loot > 0,
"not a member"
);
_;
}
modifier onlyShareholder() {
require(members[msg.sender].shares > 0, "not a shareholder");
_;
}
modifier onlyDelegate() {
require(
members[memberAddressByDelegateKey[msg.sender]].shares > 0,
"not a delegate"
);
_;
}
modifier onlyDelegateOrShaman() {
require(
members[memberAddressByDelegateKey[msg.sender]].shares > 0 ||
shamans[msg.sender],
"!delegate || !shaman"
);
_;
}
modifier onlyShaman() {
require(shamans[msg.sender], "!shaman");
_;
}
function setShaman(address _shaman, bool _enable) public onlyShaman {
shamans[_shaman] = _enable;
emit SetShaman(_shaman, _enable);
}
function setConfig(address _spamPreventionAddr, uint256 _spamPrevention)
public
onlyShaman
{
spamPreventionAddr = _spamPreventionAddr;
spamPrevention = _spamPrevention;
emit SetSpamPrevention(_spamPreventionAddr, _spamPrevention);
}
// allow member to do this if no active props
function setSharesLoot(
address[] memory _applicants,
uint256[] memory _applicantShares,
uint256[] memory _applicantLoot,
bool mint
) public onlyShaman {
require(_applicants.length == _applicantShares.length, "mismatch");
require(_applicants.length == _applicantLoot.length, "mismatch");
for (uint256 i = 0; i < _applicants.length; i++) {
_setSharesLoot(
_applicants[i],
_applicantShares[i],
_applicantLoot[i],
mint
);
// TODO: maybe emit only once in the future
emit Shaman(
_applicants[i],
_applicantShares[i],
_applicantLoot[i],
mint
);
}
}
function setSingleSharesLoot(
address _applicant,
uint256 _applicantShares,
uint256 _applicantLoot,
bool mint
) public onlyShaman {
_setSharesLoot(
_applicant,
_applicantShares,
_applicantLoot,
mint
);
// TODO: maybe emit only once in the future
emit Shaman(_applicant, _applicantShares, _applicantLoot, mint);
}
function _setSharesLoot(
address applicant,
uint256 shares,
uint256 loot,
bool mint
) internal {
if (mint) {
if (members[applicant].exists) {
members[applicant].shares = members[applicant].shares + shares;
members[applicant].loot = members[applicant].loot + loot;
// the applicant is a new member, create a new record for them
} else {
// if the applicant address is already taken by a member's delegateKey, reset it to their member address
if (members[memberAddressByDelegateKey[applicant]].exists) {
address memberToOverride = memberAddressByDelegateKey[
applicant
];
memberAddressByDelegateKey[
memberToOverride
] = memberToOverride;
members[memberToOverride].delegateKey = memberToOverride;
}
// use applicant address as delegateKey by default
members[applicant] = Member(
applicant,
shares,
loot,
true,
0,
0
);
memberAddressByDelegateKey[applicant] = applicant;
}
totalShares = totalShares + shares;
totalLoot = totalLoot + loot;
} else {
members[applicant].shares = members[applicant].shares - shares;
members[applicant].loot = members[applicant].loot - loot;
totalShares = totalShares - shares;
totalLoot = totalLoot - loot;
}
require(
(totalShares + shares + loot) <= MAX_NUMBER_OF_SHARES_AND_LOOT,
"too many shares requested"
);
}
function _setConfig(
uint256 _periodDuration,
uint256 _votingPeriodLength,
uint256 _gracePeriodLength,
uint256 _proposalDeposit,
uint256 _dilutionBound,
uint256 _processingReward
) internal {
require(_periodDuration > 0, "_periodDuration cannot be 0");
require(_votingPeriodLength > 0, "_votingPeriodLength cannot be 0");
require(
_votingPeriodLength <= MAX_VOTING_PERIOD_LENGTH,
"_votingPeriodLength exceeds limit"
);
require(
_gracePeriodLength <= MAX_GRACE_PERIOD_LENGTH,
"_gracePeriodLength exceeds limit"
);
require(_dilutionBound > 0, "_dilutionBound cannot be 0");
require(
_dilutionBound <= MAX_DILUTION_BOUND,
"_dilutionBound exceeds limit"
);
require(
_proposalDeposit >= _processingReward,
"_proposalDeposit cannot be smaller than _processingReward"
);
periodDuration = _periodDuration;
votingPeriodLength = _votingPeriodLength;
gracePeriodLength = _gracePeriodLength;
proposalDeposit = _proposalDeposit;
dilutionBound = _dilutionBound;
processingReward = _processingReward;
}
function init(
// address _summoner,
address _shaman,
address[] calldata _approvedTokens,
uint256 _periodDuration,
uint256 _votingPeriodLength,
uint256 _gracePeriodLength,
uint256 _proposalDeposit,
uint256 _dilutionBound,
uint256 _processingReward
) external {
require(!initialized, "initialized");
require(_approvedTokens.length > 0, "need at least one approved token");
require(
_approvedTokens.length <= MAX_TOKEN_WHITELIST_COUNT,
"too many tokens"
);
_setConfig(
_periodDuration,
_votingPeriodLength,
_gracePeriodLength,
_proposalDeposit,
_dilutionBound,
_processingReward
);
summoningTime = block.timestamp;
initialized = true;
depositToken = _approvedTokens[0];
shamans[_shaman] = true;
require(
totalShares <= MAX_NUMBER_OF_SHARES_AND_LOOT,
"too many shares requested"
);
for (uint256 i = 0; i < _approvedTokens.length; i++) {
require(
_approvedTokens[i] != address(0),
"_approvedToken cannot be 0"
);
require(
!tokenWhitelist[_approvedTokens[i]],
"duplicate approved token"
);
tokenWhitelist[_approvedTokens[i]] = true;
approvedTokens.push(_approvedTokens[i]);
}
}
/*****************
PROPOSAL FUNCTIONS
*****************/
function submitProposal(
address applicant,
uint256 sharesRequested,
uint256 lootRequested,
uint256 tributeOffered,
address tributeToken,
uint256 paymentRequested,
address paymentToken,
string memory details
) public nonReentrant returns (uint256 proposalId) {
require(
(sharesRequested + lootRequested) <= MAX_NUMBER_OF_SHARES_AND_LOOT,
"too many shares requested"
);
require(
tokenWhitelist[tributeToken],
"tributeToken is not whitelisted"
);
require(tokenWhitelist[paymentToken], "payment is not whitelisted");
require(applicant != address(0), "applicant cannot be 0");
require(
applicant != GUILD && applicant != ESCROW && applicant != TOTAL,
"applicant address cannot be reserved"
);
require(
members[applicant].jailed == 0,
"proposal applicant must not be jailed"
);
if (tributeOffered > 0 && userTokenBalances[GUILD][tributeToken] == 0) {
require(
totalGuildBankTokens < MAX_TOKEN_GUILDBANK_COUNT,
"cannot submit more tribute proposals for new tokens - guildbank is full"
);
}
// collect tribute from proposer and store it in the Moloch until the proposal is processed
require(
IERC20(tributeToken).transferFrom(
msg.sender,
address(this),
tributeOffered
),
"tribute token transfer failed"
);
unsafeAddToBalance(ESCROW, tributeToken, tributeOffered);
bool[6] memory flags; // [sponsored, processed, didPass, cancelled, whitelist, guildkick]
_submitProposal(
applicant,
sharesRequested,
lootRequested,
tributeOffered,
tributeToken,
paymentRequested,
paymentToken,
details,
flags
);
return proposalCount - 1; // return proposalId - contracts calling submit might want it
}
function submitWhitelistProposal(
address tokenToWhitelist,
string memory details
) public nonReentrant returns (uint256 proposalId) {
require(tokenToWhitelist != address(0), "must provide token address");
require(
!tokenWhitelist[tokenToWhitelist],
"cannot already have whitelisted the token"
);
require(
approvedTokens.length < MAX_TOKEN_WHITELIST_COUNT,
"cannot submit more whitelist proposals"
);
bool[6] memory flags; // [sponsored, processed, didPass, cancelled, whitelist, guildkick]
flags[4] = true; // whitelist
_submitProposal(
address(0),
0,
0,
0,
tokenToWhitelist,
0,
address(0),
details,
flags
);
return proposalCount - 1;
}
function submitGuildKickProposal(
address memberToKick,
string memory details
) public nonReentrant returns (uint256 proposalId) {
Member memory member = members[memberToKick];
require(
member.shares > 0 || member.loot > 0,
"member must have at least one share or one loot"
);
require(
members[memberToKick].jailed == 0,
"member must not already be jailed"
);
bool[6] memory flags; // [sponsored, processed, didPass, cancelled, whitelist, guildkick]
flags[5] = true; // guild kick
_submitProposal(
memberToKick,
0,
0,
0,
address(0),
0,
address(0),
details,
flags
);
return proposalCount - 1;
}
function _submitProposal(
address applicant,
uint256 sharesRequested,
uint256 lootRequested,
uint256 tributeOffered,
address tributeToken,
uint256 paymentRequested,
address paymentToken,
string memory details,
bool[6] memory flags
) internal {
require(msg.value >= spamPrevention, "spam prevention on");
if (spamPrevention > 0 && !shamans[msg.sender]) {
(bool success, ) = spamPreventionAddr.call{value: msg.value}("");
require(success, "failed");
}
Proposal memory proposal = Proposal({
applicant: applicant,
proposer: msg.sender,
sponsor: address(0),
sharesRequested: sharesRequested,
lootRequested: lootRequested,
tributeOffered: tributeOffered,
tributeToken: tributeToken,
paymentRequested: paymentRequested,
paymentToken: paymentToken,
startingPeriod: 0,
yesVotes: 0,
noVotes: 0,
flags: flags,
details: details,
maxTotalSharesAndLootAtYesVote: 0
});
proposals[proposalCount] = proposal;
address memberAddress = memberAddressByDelegateKey[msg.sender];
// NOTE: argument order matters, avoid stack too deep
emit SubmitProposal(
applicant,
sharesRequested,
lootRequested,
tributeOffered,
tributeToken,
paymentRequested,
paymentToken,
details,
flags,
proposalCount,
msg.sender,
memberAddress
);
proposalCount += 1;
}
function sponsorProposal(uint256 proposalId)
public
nonReentrant
onlyDelegate
{
// collect proposal deposit from sponsor and store it in the Moloch until the proposal is processed
require(
IERC20(depositToken).transferFrom(
msg.sender,
address(this),
proposalDeposit
),
"proposal deposit token transfer failed"
);
unsafeAddToBalance(ESCROW, depositToken, proposalDeposit);
Proposal storage proposal = proposals[proposalId];
require(
proposal.proposer != address(0),
"proposal must have been proposed"
);
require(!proposal.flags[0], "proposal has already been sponsored");
require(!proposal.flags[3], "proposal has been cancelled");
require(
members[proposal.applicant].jailed == 0,
"proposal applicant must not be jailed"
);
if (
proposal.tributeOffered > 0 &&
userTokenBalances[GUILD][proposal.tributeToken] == 0
) {
require(
totalGuildBankTokens < MAX_TOKEN_GUILDBANK_COUNT,
"cannot sponsor more tribute proposals for new tokens - guildbank is full"
);
}
// whitelist proposal
if (proposal.flags[4]) {
require(
!tokenWhitelist[address(proposal.tributeToken)],
"cannot already have whitelisted the token"
);
require(
!proposedToWhitelist[address(proposal.tributeToken)],
"already proposed to whitelist"
);
require(
approvedTokens.length < MAX_TOKEN_WHITELIST_COUNT,
"cannot sponsor more whitelist proposals"
);
proposedToWhitelist[address(proposal.tributeToken)] = true;
// guild kick proposal
} else if (proposal.flags[5]) {
require(
!proposedToKick[proposal.applicant],
"already proposed to kick"
);
proposedToKick[proposal.applicant] = true;
}
// compute startingPeriod for proposal
uint256 startingPeriod = max(
getCurrentPeriod(),
proposalQueue.length == 0
? 0
: proposals[proposalQueue[proposalQueue.length - 1]]
.startingPeriod
) + 1;
proposal.startingPeriod = startingPeriod;
address memberAddress = memberAddressByDelegateKey[msg.sender];
proposal.sponsor = memberAddress;
proposal.flags[0] = true; // sponsored
// append proposal to the queue
proposalQueue.push(proposalId);
emit SponsorProposal(
msg.sender,
memberAddress,
proposalId,
proposalQueue.length - 1,
startingPeriod
);
}
// NOTE: In MolochV2 proposalIndex !== proposalId
function submitVote(uint256 proposalIndex, uint8 uintVote)
public
nonReentrant
onlyDelegate
{
address memberAddress = memberAddressByDelegateKey[msg.sender];
Member storage member = members[memberAddress];
require(
proposalIndex < proposalQueue.length,
"proposal does not exist"
);
Proposal storage proposal = proposals[proposalQueue[proposalIndex]];
require(uintVote < 3, "must be less than 3");
Vote vote = Vote(uintVote);
require(
getCurrentPeriod() >= proposal.startingPeriod,
"voting period has not started"
);
require(
!hasVotingPeriodExpired(proposal.startingPeriod),
"proposal voting period has expired"
);
require(
voteHistory[proposalIndex][memberAddress] == Vote.Null,
"member has already voted"
);
require(
vote == Vote.Yes || vote == Vote.No,
"vote must be either Yes or No"
);
voteHistory[proposalIndex][memberAddress] = vote;
if (vote == Vote.Yes) {
proposal.yesVotes = proposal.yesVotes + member.shares;
// set highest index (latest) yes vote - must be processed for member to ragequit
if (proposalIndex > member.highestIndexYesVote) {
member.highestIndexYesVote = proposalIndex;
}
// set maximum of total shares encountered at a yes vote - used to bound dilution for yes voters
if (
(totalShares + totalLoot) >
proposal.maxTotalSharesAndLootAtYesVote
) {
proposal.maxTotalSharesAndLootAtYesVote =
totalShares +
totalLoot;
}
} else if (vote == Vote.No) {
proposal.noVotes = proposal.noVotes + member.shares;
}
// NOTE: subgraph indexes by proposalId not proposalIndex since proposalIndex isn't set untill it's been sponsored but proposal is created on submission
emit SubmitVote(
proposalQueue[proposalIndex],
proposalIndex,
msg.sender,
memberAddress,
uintVote
);
}
function processProposal(uint256 proposalIndex) public nonReentrant {
_validateProposalForProcessing(proposalIndex);
uint256 proposalId = proposalQueue[proposalIndex];
Proposal storage proposal = proposals[proposalId];
require(
!proposal.flags[4] && !proposal.flags[5],
"must be a standard proposal"
);
proposal.flags[1] = true; // processed
bool didPass = _didPass(proposalIndex);
// Make the proposal fail if the new total number of shares and loot exceeds the limit
if (
(totalShares +
totalLoot +
proposal.sharesRequested +
proposal.lootRequested) > MAX_NUMBER_OF_SHARES_AND_LOOT
) {
didPass = false;
}
// Make the proposal fail if it is requesting more tokens as payment than the available guild bank balance
if (
proposal.paymentRequested >
userTokenBalances[GUILD][proposal.paymentToken]
) {
didPass = false;
}
// Make the proposal fail if it would result in too many tokens with non-zero balance in guild bank
if (
proposal.tributeOffered > 0 &&
userTokenBalances[GUILD][proposal.tributeToken] == 0 &&
totalGuildBankTokens >= MAX_TOKEN_GUILDBANK_COUNT
) {
didPass = false;
}
// PROPOSAL PASSED
if (didPass) {
proposal.flags[2] = true; // didPass
_setSharesLoot(
proposal.applicant,
proposal.sharesRequested,
proposal.lootRequested,
true
);
// if the proposal tribute is the first tokens of its kind to make it into the guild bank, increment total guild bank tokens
if (
userTokenBalances[GUILD][proposal.tributeToken] == 0 &&
proposal.tributeOffered > 0
) {
totalGuildBankTokens += 1;
}
unsafeInternalTransfer(
ESCROW,
GUILD,
proposal.tributeToken,
proposal.tributeOffered
);
unsafeInternalTransfer(
GUILD,
proposal.applicant,
proposal.paymentToken,
proposal.paymentRequested
);
// if the proposal spends 100% of guild bank balance for a token, decrement total guild bank tokens
if (
userTokenBalances[GUILD][proposal.paymentToken] == 0 &&
proposal.paymentRequested > 0
) {
totalGuildBankTokens -= 1;
}
// PROPOSAL FAILED
} else {
// return all tokens to the proposer (not the applicant, because funds come from proposer)
unsafeInternalTransfer(
ESCROW,
proposal.proposer,
proposal.tributeToken,
proposal.tributeOffered
);
}
_returnDeposit(proposal.sponsor);
emit ProcessProposal(proposalIndex, proposalId, didPass);
}
function processWhitelistProposal(uint256 proposalIndex)
public
nonReentrant
{
_validateProposalForProcessing(proposalIndex);
uint256 proposalId = proposalQueue[proposalIndex];
Proposal storage proposal = proposals[proposalId];
require(proposal.flags[4], "must be a whitelist proposal");
proposal.flags[1] = true; // processed
bool didPass = _didPass(proposalIndex);
if (approvedTokens.length >= MAX_TOKEN_WHITELIST_COUNT) {
didPass = false;
}
if (didPass) {
proposal.flags[2] = true; // didPass
tokenWhitelist[address(proposal.tributeToken)] = true;
approvedTokens.push(proposal.tributeToken);
}
proposedToWhitelist[address(proposal.tributeToken)] = false;
_returnDeposit(proposal.sponsor);
emit ProcessWhitelistProposal(proposalIndex, proposalId, didPass);
}
function processGuildKickProposal(uint256 proposalIndex)
public
nonReentrant
{
_validateProposalForProcessing(proposalIndex);
uint256 proposalId = proposalQueue[proposalIndex];
Proposal storage proposal = proposals[proposalId];
require(proposal.flags[5], "must be a guild kick proposal");
proposal.flags[1] = true; // processed
bool didPass = _didPass(proposalIndex);
if (didPass) {
proposal.flags[2] = true; // didPass
Member storage member = members[proposal.applicant];
member.jailed = proposalIndex;
// transfer shares to loot
member.loot = member.loot + member.shares;
totalShares = totalShares - member.shares;
totalLoot = totalLoot + member.shares;
member.shares = 0; // revoke all shares
}
proposedToKick[proposal.applicant] = false;
_returnDeposit(proposal.sponsor);
emit ProcessGuildKickProposal(proposalIndex, proposalId, didPass);
}
function _didPass(uint256 proposalIndex)
internal
view
returns (bool didPass)
{
Proposal memory proposal = proposals[proposalQueue[proposalIndex]];
didPass = proposal.yesVotes > proposal.noVotes;
// Make the proposal fail if the dilutionBound is exceeded
if (
(totalShares + totalLoot) * (dilutionBound) <
proposal.maxTotalSharesAndLootAtYesVote
) {
didPass = false;
}
// Make the proposal fail if the applicant is jailed
// - for standard proposals, we don't want the applicant to get any shares/loot/payment
// - for guild kick proposals, we should never be able to propose to kick a jailed member (or have two kick proposals active), so it doesn't matter
if (members[proposal.applicant].jailed != 0) {
didPass = false;
}
return didPass;
}
function _validateProposalForProcessing(uint256 proposalIndex)
internal
view
{
require(
proposalIndex < proposalQueue.length,
"proposal does not exist"
);
Proposal memory proposal = proposals[proposalQueue[proposalIndex]];
require(
getCurrentPeriod() >=
(proposal.startingPeriod +
votingPeriodLength +
gracePeriodLength),
"proposal is not ready to be processed"
);
require(
proposal.flags[1] == false,
"proposal has already been processed"
);
require(
proposalIndex == 0 ||
proposals[proposalQueue[proposalIndex - 1]].flags[1],
"previous proposal must be processed"
);
}
function _returnDeposit(address sponsor) internal {
unsafeInternalTransfer(
ESCROW,
msg.sender,
depositToken,
processingReward
);
unsafeInternalTransfer(
ESCROW,
sponsor,
depositToken,
proposalDeposit - processingReward
);
}
function ragequit(uint256 sharesToBurn, uint256 lootToBurn)
public
nonReentrant
onlyMember
{
_ragequit(msg.sender, sharesToBurn, lootToBurn);
}
function _ragequit(
address memberAddress,
uint256 sharesToBurn,
uint256 lootToBurn
) internal {
uint256 initialTotalSharesAndLoot = totalShares + totalLoot;
Member storage member = members[memberAddress];
require(member.shares >= sharesToBurn, "insufficient shares");
require(member.loot >= lootToBurn, "insufficient loot");
require(
canRagequit(member.highestIndexYesVote),
"cannot ragequit until highest index proposal member voted YES on is processed"
);
uint256 sharesAndLootToBurn = sharesToBurn + lootToBurn;
// burn shares and loot
_setSharesLoot(memberAddress, sharesToBurn, lootToBurn, false);
for (uint256 i = 0; i < approvedTokens.length; i++) {
uint256 amountToRagequit = fairShare(
userTokenBalances[GUILD][approvedTokens[i]],
sharesAndLootToBurn,
initialTotalSharesAndLoot
);
if (amountToRagequit > 0) {
// gas optimization to allow a higher maximum token limit
// deliberately not using safemath here to keep overflows from preventing the function execution (which would break ragekicks)
// if a token overflows, it is because the supply was artificially inflated to oblivion, so we probably don't care about it anyways
userTokenBalances[GUILD][approvedTokens[i]] -= amountToRagequit;
userTokenBalances[memberAddress][
approvedTokens[i]
] += amountToRagequit;
}
}
emit Ragequit(memberAddress, sharesToBurn, lootToBurn);
}
function ragekick(address memberToKick) public nonReentrant {
Member storage member = members[memberToKick];
require(member.jailed != 0, "member must be in jail");
require(member.loot > 0, "member must have some loot"); // note - should be impossible for jailed member to have shares
require(
canRagequit(member.highestIndexYesVote),
"cannot ragequit until highest index proposal member voted YES on is processed"
);
_ragequit(memberToKick, 0, member.loot);
}
function withdrawBalance(address token, uint256 amount)
public
nonReentrant
{
_withdrawBalance(token, amount);
}
function withdrawBalances(
address[] memory tokens,
uint256[] memory amounts,
bool shouldWithdrawMax
) public nonReentrant {
require(
tokens.length == amounts.length,
"tokens and amounts arrays must be matching lengths"
);
for (uint256 i = 0; i < tokens.length; i++) {
uint256 withdrawAmount = amounts[i];
if (shouldWithdrawMax) {
// withdraw the maximum balance
withdrawAmount = userTokenBalances[msg.sender][tokens[i]];
}
_withdrawBalance(tokens[i], withdrawAmount);
}
}
function _withdrawBalance(address token, uint256 amount) internal {
require(
userTokenBalances[msg.sender][token] >= amount,
"insufficient balance"
);
unsafeSubtractFromBalance(msg.sender, token, amount);
require(IERC20(token).transfer(msg.sender, amount), "transfer failed");
emit Withdraw(msg.sender, token, amount);
}
function collectTokens(address token)
public
onlyDelegateOrShaman
nonReentrant
{
uint256 amountToCollect = IERC20(token).balanceOf(address(this)) -
userTokenBalances[TOTAL][token];
// only collect if 1) there are tokens to collect 2) token is whitelisted 3) token has non-zero balance
require(amountToCollect > 0, "no tokens to collect");
require(tokenWhitelist[token], "token to collect must be whitelisted");
require(
userTokenBalances[GUILD][token] > 0 ||
totalGuildBankTokens < MAX_TOKEN_GUILDBANK_COUNT,
"token to collect must have non-zero guild bank balance"
);
if (userTokenBalances[GUILD][token] == 0) {
totalGuildBankTokens += 1;
}
unsafeAddToBalance(GUILD, token, amountToCollect);
emit TokensCollected(token, amountToCollect);
}
// NOTE: requires that delegate key which sent the original proposal cancels, msg.sender == proposal.proposer
function cancelProposal(uint256 proposalId) public nonReentrant {
Proposal storage proposal = proposals[proposalId];
require(!proposal.flags[0], "proposal has already been sponsored");
require(!proposal.flags[3], "proposal has already been cancelled");
require(
msg.sender == proposal.proposer,
"solely the proposer can cancel"
);
proposal.flags[3] = true; // cancelled
unsafeInternalTransfer(
ESCROW,
proposal.proposer,
proposal.tributeToken,
proposal.tributeOffered
);
emit CancelProposal(proposalId, msg.sender);
}
function updateDelegateKey(address newDelegateKey)
public
nonReentrant
onlyShareholder
{
require(newDelegateKey != address(0), "newDelegateKey cannot be 0");
// skip checks if member is setting the delegate key to their member address
if (newDelegateKey != msg.sender) {
require(
!members[newDelegateKey].exists,
"cannot overwrite existing members"
);
require(
!members[memberAddressByDelegateKey[newDelegateKey]].exists,
"cannot overwrite existing delegate keys"
);
}
Member storage member = members[msg.sender];
memberAddressByDelegateKey[member.delegateKey] = address(0);
memberAddressByDelegateKey[newDelegateKey] = msg.sender;
member.delegateKey = newDelegateKey;
emit UpdateDelegateKey(msg.sender, newDelegateKey);
}
// can only ragequit if the latest proposal you voted YES on has been processed
function canRagequit(uint256 highestIndexYesVote)
public
view
returns (bool)
{
// TODO: fixed to allow ragequit before any proposals, write test
if(proposalQueue.length == 0){
return true;
}
require(
highestIndexYesVote < proposalQueue.length,
"proposal does not exist"
);
return proposals[proposalQueue[highestIndexYesVote]].flags[1];
}
function hasVotingPeriodExpired(uint256 startingPeriod)
public
view
returns (bool)
{
return getCurrentPeriod() >= (startingPeriod + votingPeriodLength);
}
/***************
GETTER FUNCTIONS
***************/
function max(uint256 x, uint256 y) internal pure returns (uint256) {
return x >= y ? x : y;
}
function getCurrentPeriod() public view returns (uint256) {
return (block.timestamp - summoningTime) / (periodDuration);
}
function getProposalQueueLength() public view returns (uint256) {
return proposalQueue.length;
}
function getProposalFlags(uint256 proposalId)
public
view
returns (bool[6] memory)
{
return proposals[proposalId].flags;
}
function getUserTokenBalance(address user, address token)
public
view
returns (uint256)
{
return userTokenBalances[user][token];
}
function getMemberProposalVote(address memberAddress, uint256 proposalIndex)
public
view
returns (Vote)
{
require(members[memberAddress].exists, "member does not exist");
require(
proposalIndex < proposalQueue.length,
"proposal does not exist"
);
return voteHistory[proposalIndex][memberAddress];
}
function getTokenCount() public view returns (uint256) {
return approvedTokens.length;
}
/***************
HELPER FUNCTIONS
***************/
function unsafeAddToBalance(
address user,
address token,
uint256 amount
) internal {
userTokenBalances[user][token] += amount;
userTokenBalances[TOTAL][token] += amount;
}
function unsafeSubtractFromBalance(
address user,
address token,
uint256 amount
) internal {
userTokenBalances[user][token] -= amount;
userTokenBalances[TOTAL][token] -= amount;
}
function unsafeInternalTransfer(
address from,
address to,
address token,
uint256 amount
) internal {
unsafeSubtractFromBalance(from, token, amount);
unsafeAddToBalance(to, token, amount);
}
function fairShare(
uint256 balance,
uint256 shares,
uint256 _totalShares
) internal pure returns (uint256) {
require(_totalShares != 0);
if (balance == 0) {
return 0;
}
uint256 prod = balance * shares;
if (prod / balance == shares) {
// no overflow in multiplication above?
return prod / _totalShares;
}
return (balance / _totalShares) * shares;
}
}
/*
The MIT License (MIT)
Copyright (c) 2018 Murray Software, LLC.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
contract CloneFactory {
// implementation of eip-1167 - see https://eips.ethereum.org/EIPS/eip-1167
function createClone(address target) internal returns (address result) {
bytes20 targetBytes = bytes20(target);
assembly {
let clone := mload(0x40)
mstore(
clone,
0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
)
mstore(add(clone, 0x14), targetBytes)
mstore(
add(clone, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
result := create(0, clone, 0x37)
}
}
}
contract MolochSummoner is CloneFactory {
address public template;
mapping(uint256 => address) public daos;
uint256 public daoIdx = 0;
// Moloch private moloch; // moloch contract
constructor(address _template) {
template = _template;
}
event SummonComplete(
address indexed moloch,
address _summoner,
address _shaman,
address[] tokens,
uint256 summoningTime,
uint256 periodDuration,
uint256 votingPeriodLength,
uint256 gracePeriodLength,
uint256 proposalDeposit,
uint256 dilutionBound,
uint256 processingReward
);
function summonMoloch(
address _summoner,
address _shaman,
address[] memory _approvedTokens,
uint256 _periodDuration,
uint256 _votingPeriodLength,
uint256 _gracePeriodLength,
uint256 _proposalDeposit,
uint256 _dilutionBound,
uint256 _processingReward
) public returns (address) {
Moloch moloch = Moloch(createClone(template));
moloch.init(
// _summoner,
_shaman,
_approvedTokens,
_periodDuration,
_votingPeriodLength,
_gracePeriodLength,
_proposalDeposit,
_dilutionBound,
_processingReward
);
daoIdx = daoIdx + 1;
daos[daoIdx] = address(moloch);
emit SummonComplete(
address(moloch),
_summoner,
_shaman,
_approvedTokens,
block.timestamp,
_periodDuration,
_votingPeriodLength,
_gracePeriodLength,
_proposalDeposit,
_dilutionBound,
_processingReward
);
return address(moloch);
}
} | the # of shares the applicant is requesting
| uint256 sharesRequested; | 32,906 | [
1,
5787,
225,
434,
24123,
326,
513,
1780,
970,
353,
18709,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
2254,
5034,
24123,
11244,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
//SPDX-License-Identifier: none
pragma solidity ^0.8.0;
import "./RarumNFT_Permit.sol";
contract RarumNFT is ERC1155PresetMinterPauserUpgradeable, RarumNFT_Permit {
string public name;
string public symbol;
string public description;
mapping (uint256 => string) private _tokenURIs;
uint256[] public tokenIds; // list of token ids - order is not important
/**
* @dev Grants `OPERATOR_ROLE` to the account that deploys the contract.
*/
function initialize(
string calldata _uri,
string calldata _name,
string calldata _symbol,
string calldata _description
)
public
initializer
{
__ERC1155PresetMinterPauser_init(_uri);
__EIP712_init("https://rarum.io", "1");
_setupRole(BURNER_ROLE, _msgSender());
_setupRole(OPERATOR_ROLE, _msgSender());
name = _name;
symbol = _symbol;
description = _description;
}
function registerToken(
uint256 id,
string calldata cid
)
external
onlyMinter
{
require(bytes(_tokenURIs[id]).length == 0, "RarumNFT: token already registered");
tokenIds.push(id);
_setTokenURI(id, cid);
}
function batchRegisterToken(
uint256[] calldata ids,
string[] calldata cids
)
external
onlyMinter
{
require(ids.length == cids.length, "RarumNFT: ids and cids length mismatch");
for (uint i = 0; i < ids.length; i++) {
require(bytes(_tokenURIs[ids[i]]).length == 0, "RarumNFT: token already registered");
tokenIds.push(ids[i]);
_setTokenURI(ids[i], cids[i]);
}
}
function isRegistered(
uint256 id
) external view returns (bool) {
return bytes(_tokenURIs[id]).length != 0;
}
function getRegisteredTokens()
external view returns (uint256[] memory) {
return tokenIds;
}
function balancesOf(
address wallet
) external view returns (uint256[] memory tokens, uint256[] memory balances) {
uint256[] memory tokens = tokenIds;
uint256[] memory balances = new uint256[](tokens.length);
for (uint256 i = 0; i < tokens.length; ++i) {
balances[i] = balanceOf(wallet, tokens[i]);
}
return (tokens, balances);
}
/**
* @dev Creates `amount` new tokens for `to`, of token type `id` and adds a default operator
*
* See {ERC1155-_mint}.
*
* Requirements:
*
* - the caller must have the `MINTER_ROLE`.
*/
function mint(
address to,
uint256 id,
uint256 amount,
bytes calldata data
)
public
override
{
require(bytes(_tokenURIs[id]).length != 0, "RarumNFT: token is not registered");
super.mint(to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] variant of {mint} and adds a default operator.
*/
function mintBatch(
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
)
public
override
{
for (uint i = 0; i < ids.length; i++) {
require(bytes(_tokenURIs[ids[i]]).length != 0, "RarumNFT: token is not registered");
}
super.mintBatch(to, ids, amounts, data);
}
function burn(
address account,
uint256 id,
uint256 value
)
public
override
onlyBurner
{
_burn(account, id, value);
}
function burnBatch(
address account,
uint256[] calldata ids,
uint256[] calldata values
)
public
override
onlyBurner
{
_burnBatch(account, ids, values);
}
function uri(uint256 _id) public view override returns (string memory) {
return _tokenURI(_id);
}
/**
* @dev Returns an URI for a given token ID. If tokenId is 0, returns _uri
* @param tokenId uint256 ID of the token to query
*/
function _tokenURI(uint256 tokenId) internal view returns (string memory) {
if (tokenId == 0) return _uri;
return _tokenURIs[tokenId];
}
/**
* @dev Internal function to set the token cid for a given token.
* @param tokenId uint256 ID of the token to set its URI
* @param cid string ipfs cid to assign
*/
function _setTokenURI(uint256 tokenId, string memory cid) internal {
_tokenURIs[tokenId] = string(abi.encodePacked(_uri, cid));
emit URI(_tokenURIs[tokenId], tokenId);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
import "./RarumNFT_Roles.sol";
/**
* @dev Adaptation of OpenZeppelin's ERC20Permit
*/
contract RarumNFT_Permit is RarumNFT_Roles, EIP712Upgradeable {
address public tokenAddress;
mapping(address => mapping(bytes32 => bool)) internal _authorizationStates;
event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);
// solhint-disable-next-line var-name-mixedcase
bytes32 private constant _PERMIT_TYPEHASH = keccak256("Permit(address owner,address operator,bool approved,bytes32 nonce,uint256 deadline)");
/**
* @dev See {IERC20Permit-permit}.
*/
function permit(
address owner,
address operator,
bool approved,
bytes32 nonce,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public onlyOperator {
// solhint-disable-next-line not-rely-on-time
require(block.timestamp <= deadline, "RarumNFT_Permit: expired deadline");
require(
!_authorizationStates[owner][nonce],
"RarumNFT_Permit: authorization is used"
);
bytes32 structHash = keccak256(
abi.encode(
_PERMIT_TYPEHASH,
owner,
operator,
approved,
nonce,
deadline
)
);
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSAUpgradeable.recover(hash, v, r, s);
require(signer == owner, "RarumNFT_Permit: invalid signature");
_authorizationStates[owner][nonce] = true;
_setApprovalForAll(owner, operator, approved);
emit AuthorizationUsed(owner, nonce);
}
function _setApprovalForAll(address owner, address operator, bool approved) internal {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function authorizationState(address authorizer, bytes32 nonce)
external
view
returns (bool)
{
return _authorizationStates[authorizer][nonce];
}
/**
* @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32) {
return _domainSeparatorV4();
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ECDSAUpgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
*
* The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
* thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
* they need in their contracts using a combination of `abi.encode` and `keccak256`.
*
* This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
* scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
* ({_hashTypedDataV4}).
*
* The implementation of the domain separator was designed to be as efficient as possible while still properly updating
* the chain id to protect against replay attacks on an eventual fork of the chain.
*
* NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
* https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
*
* _Available since v3.4._
*/
abstract contract EIP712Upgradeable is Initializable {
/* solhint-disable var-name-mixedcase */
bytes32 private _HASHED_NAME;
bytes32 private _HASHED_VERSION;
bytes32 private constant _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
/* solhint-enable var-name-mixedcase */
/**
* @dev Initializes the domain separator and parameter caches.
*
* The meaning of `name` and `version` is specified in
* https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
*
* - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
* - `version`: the current major version of the signing domain.
*
* NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
* contract upgrade].
*/
function __EIP712_init(string memory name, string memory version) internal initializer {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal initializer {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
}
/**
* @dev Returns the domain separator for the current chain.
*/
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());
}
function _buildDomainSeparator(
bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash
) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
/**
* @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
* function returns the hash of the fully encoded EIP712 message for this domain.
*
* This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
*
* ```solidity
* bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
* keccak256("Mail(address to,string contents)"),
* mailTo,
* keccak256(bytes(mailContents))
* )));
* address signer = ECDSA.recover(digest, signature);
* ```
*/
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
}
/**
* @dev The hash of the name parameter for the EIP712 domain.
*
* NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
* are a concern.
*/
function _EIP712NameHash() internal virtual view returns (bytes32) {
return _HASHED_NAME;
}
/**
* @dev The hash of the version parameter for the EIP712 domain.
*
* NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
* are a concern.
*/
function _EIP712VersionHash() internal virtual view returns (bytes32) {
return _HASHED_VERSION;
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSAUpgradeable {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature` or error string. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*
* _Available since v4.3._
*/
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return tryRecover(hash, v, r, s);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*
* _Available since v4.2._
*/
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*
* _Available since v4.3._
*/
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (301): 0 < s < secp256k1n รท 2 + 1, and for v in (302): v โ {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
/**
* @dev Returns an Ethereum Signed Message, created from a `hash`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
/**
* @dev Returns an Ethereum Signed Typed Data, created from a
* `domainSeparator` and a `structHash`. This produces hash corresponding
* to the one signed with the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
* JSON-RPC method as part of EIP-712.
*
* See {recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
//SPDX-License-Identifier: none
pragma solidity ^0.8.0;
import "./ERC1155/presets/ERC1155PresetMinterPauserUpgradeable.sol";
contract RarumNFT_Roles is ERC1155PresetMinterPauserUpgradeable {
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
modifier onlyMinter() {
require(hasRole(MINTER_ROLE, _msgSender()), "RarumNFT: caller is not a MINTER");
_;
}
modifier onlyOperator() {
require(hasRole(OPERATOR_ROLE, _msgSender()), "RarumNFT: caller is not an OPERATOR");
_;
}
modifier onlyBurner() {
require(hasRole(BURNER_ROLE, _msgSender()), "RarumNFT: caller is not a BURNER");
_;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Modifier to protect an initializer function from being invoked twice.
*/
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../ERC1155Upgradeable.sol";
import "../extensions/ERC1155BurnableUpgradeable.sol";
import "../extensions/ERC1155PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
/**
* @dev {ERC1155} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - a pauser role that allows to stop all token transfers
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
contract ERC1155PresetMinterPauserUpgradeable is Initializable, ContextUpgradeable, AccessControlEnumerableUpgradeable, ERC1155BurnableUpgradeable, ERC1155PausableUpgradeable {
function initialize(string memory uri) public virtual initializer {
__ERC1155PresetMinterPauser_init(uri);
}
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
/**
* @dev Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE`, and `PAUSER_ROLE` to the account that
* deploys the contract.
*/
function __ERC1155PresetMinterPauser_init(string memory uri) internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__AccessControl_init_unchained();
__AccessControlEnumerable_init_unchained();
__ERC1155_init_unchained(uri);
__ERC1155Burnable_init_unchained();
__Pausable_init_unchained();
__ERC1155Pausable_init_unchained();
__ERC1155PresetMinterPauser_init_unchained(uri);
}
function __ERC1155PresetMinterPauser_init_unchained(string memory uri) internal initializer {
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setupRole(MINTER_ROLE, _msgSender());
_setupRole(PAUSER_ROLE, _msgSender());
}
/**
* @dev Creates `amount` new tokens for `to`, of token type `id`.
*
* See {ERC1155-_mint}.
*
* Requirements:
*
* - the caller must have the `MINTER_ROLE`.
*/
function mint(address to, uint256 id, uint256 amount, bytes memory data) public virtual {
require(hasRole(MINTER_ROLE, _msgSender()), "ERC1155PresetMinterPauser: must have minter role to mint");
_mint(to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] variant of {mint}.
*/
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) public virtual {
require(hasRole(MINTER_ROLE, _msgSender()), "ERC1155PresetMinterPauser: must have minter role to mint");
_mintBatch(to, ids, amounts, data);
}
/**
* @dev Pauses all token transfers.
*
* See {ERC1155Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public virtual {
require(hasRole(PAUSER_ROLE, _msgSender()), "ERC1155PresetMinterPauser: must have pauser role to pause");
_pause();
}
/**
* @dev Unpauses all token transfers.
*
* See {ERC1155Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public virtual {
require(hasRole(PAUSER_ROLE, _msgSender()), "ERC1155PresetMinterPauser: must have pauser role to unpause");
_unpause();
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerableUpgradeable, ERC1155Upgradeable) returns (bool) {
return super.supportsInterface(interfaceId);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
)
internal virtual override(ERC1155Upgradeable, ERC1155PausableUpgradeable)
{
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC1155Upgradeable.sol";
import "./IERC1155ReceiverUpgradeable.sol";
import "./extensions/IERC1155MetadataURIUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
contract ERC1155Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC1155Upgradeable, IERC1155MetadataURIUpgradeable {
using AddressUpgradeable for address;
// Mapping from token ID to account balances
mapping (uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping (address => mapping(address => bool)) internal _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string internal _uri;
/**
* @dev See {_setURI}.
*/
function __ERC1155_init(string memory uri_) internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__ERC1155_init_unchained(uri_);
}
function __ERC1155_init_unchained(string memory uri_) internal initializer {
_setURI(uri_);
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return interfaceId == type(IERC1155Upgradeable).interfaceId
|| interfaceId == type(IERC1155MetadataURIUpgradeable).interfaceId
|| super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the `\{id\}` substring with the
* actual token type ID.
*/
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: balance query for the zero address");
return _balances[id][account];
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(
address[] memory accounts,
uint256[] memory ids
)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(_msgSender() != operator, "ERC1155: setting approval status for self");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
)
public
virtual
override
{
require(to != address(0), "ERC1155: transfer to the zero address");
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
_balances[id][from] = fromBalance - amount;
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
)
public
virtual
override
{
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: transfer caller is not owner nor approved"
);
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
_balances[id][from] = fromBalance - amount;
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `account`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - If `account` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(address account, uint256 id, uint256 amount, bytes memory data) internal virtual {
require(account != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), account, _asSingletonArray(id), _asSingletonArray(amount), data);
_balances[id][account] += amount;
emit TransferSingle(operator, address(0), account, id, amount);
_doSafeTransferAcceptanceCheck(operator, address(0), account, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
/**
* @dev Destroys `amount` tokens of token type `id` from `account`
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens of token type `id`.
*/
function _burn(address account, uint256 id, uint256 amount) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
uint256 accountBalance = _balances[id][account];
require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
_balances[id][account] = accountBalance - amount;
emit TransferSingle(operator, account, address(0), id, amount);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(address account, uint256[] memory ids, uint256[] memory amounts) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), ids, amounts, "");
for (uint i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 accountBalance = _balances[id][account];
require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
_balances[id][account] = accountBalance - amount;
}
emit TransferBatch(operator, account, address(0), ids, amounts);
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
)
internal
virtual
{ }
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
)
private
{
if (to.isContract()) {
try IERC1155ReceiverUpgradeable(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155ReceiverUpgradeable(to).onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
)
private
{
if (to.isContract()) {
try IERC1155ReceiverUpgradeable(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) {
if (response != IERC1155ReceiverUpgradeable(to).onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
uint256[47] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../ERC1155Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
/**
* @dev Extension of {ERC1155} that allows token holders to destroy both their
* own tokens and those that they have been approved to use.
*
* _Available since v3.1._
*/
abstract contract ERC1155BurnableUpgradeable is Initializable, ERC1155Upgradeable {
function __ERC1155Burnable_init() internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__ERC1155Burnable_init_unchained();
}
function __ERC1155Burnable_init_unchained() internal initializer {
}
function burn(address account, uint256 id, uint256 value) public virtual {
require(
account == _msgSender() || isApprovedForAll(account, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
_burn(account, id, value);
}
function burnBatch(address account, uint256[] memory ids, uint256[] memory values) public virtual {
require(
account == _msgSender() || isApprovedForAll(account, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
_burnBatch(account, ids, values);
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../ERC1155Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
/**
* @dev ERC1155 token with pausable token transfers, minting and burning.
*
* Useful for scenarios such as preventing trades until the end of an evaluation
* period, or having an emergency switch for freezing all token transfers in the
* event of a large bug.
*
* _Available since v3.1._
*/
abstract contract ERC1155PausableUpgradeable is Initializable, ERC1155Upgradeable, PausableUpgradeable {
function __ERC1155Pausable_init() internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__Pausable_init_unchained();
__ERC1155Pausable_init_unchained();
}
function __ERC1155Pausable_init_unchained() internal initializer {
}
/**
* @dev See {ERC1155-_beforeTokenTransfer}.
*
* Requirements:
*
* - the contract must not be paused.
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
)
internal
virtual
override
{
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
require(!paused(), "ERC1155Pausable: token transfer while paused");
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IAccessControlEnumerableUpgradeable.sol";
import "./AccessControlUpgradeable.sol";
import "../utils/structs/EnumerableSetUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Extension of {AccessControl} that allows enumerating the members of each role.
*/
abstract contract AccessControlEnumerableUpgradeable is Initializable, IAccessControlEnumerableUpgradeable, AccessControlUpgradeable {
function __AccessControlEnumerable_init() internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__AccessControl_init_unchained();
__AccessControlEnumerable_init_unchained();
}
function __AccessControlEnumerable_init_unchained() internal initializer {
}
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
mapping(bytes32 => EnumerableSetUpgradeable.AddressSet) private _roleMembers;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlEnumerableUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) public view override returns (address) {
return _roleMembers[role].at(index);
}
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) public view override returns (uint256) {
return _roleMembers[role].length();
}
/**
* @dev Overload {grantRole} to track enumerable memberships
*/
function grantRole(bytes32 role, address account) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
super.grantRole(role, account);
_roleMembers[role].add(account);
}
/**
* @dev Overload {revokeRole} to track enumerable memberships
*/
function revokeRole(bytes32 role, address account) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
super.revokeRole(role, account);
_roleMembers[role].remove(account);
}
/**
* @dev Overload {renounceRole} to track enumerable memberships
*/
function renounceRole(bytes32 role, address account) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
super.renounceRole(role, account);
_roleMembers[role].remove(account);
}
/**
* @dev Overload {_setupRole} to track enumerable memberships
*/
function _setupRole(bytes32 role, address account) internal virtual override {
super._setupRole(role, account);
_roleMembers[role].add(account);
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
/**
* @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 ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol";
/**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/
interface IERC1155Upgradeable is IERC165Upgradeable {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
* transfers.
*/
event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values);
/**
* @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
* `approved`.
*/
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
/**
* @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
*
* If an {URI} event was emitted for `id`, the standard
* https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
* returned by {IERC1155MetadataURI-uri}.
*/
event URI(string value, uint256 indexed id);
/**
* @dev Returns the amount of tokens of token type `id` owned by `account`.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) external view returns (uint256);
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory);
/**
* @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
*
* Emits an {ApprovalForAll} event.
*
* Requirements:
*
* - `operator` cannot be the caller.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
*
* See {setApprovalForAll}.
*/
function isApprovedForAll(address account, address operator) external view returns (bool);
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data) external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol";
/**
* @dev _Available since v3.1._
*/
interface IERC1155ReceiverUpgradeable is IERC165Upgradeable {
/**
@dev Handles the receipt of a single ERC1155 token type. This function is
called at the end of a `safeTransferFrom` after the balance has been updated.
To accept the transfer, this must return
`bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
(i.e. 0xf23a6e61, or its own function selector).
@param operator The address which initiated the transfer (i.e. msg.sender)
@param from The address which previously owned the token
@param id The ID of the token being transferred
@param value The amount of tokens being transferred
@param data Additional data with no specified format
@return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
*/
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
)
external
returns(bytes4);
/**
@dev Handles the receipt of a multiple ERC1155 token types. This function
is called at the end of a `safeBatchTransferFrom` after the balances have
been updated. To accept the transfer(s), this must return
`bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
(i.e. 0xbc197c81, or its own function selector).
@param operator The address which initiated the batch transfer (i.e. msg.sender)
@param from The address which previously owned the token
@param ids An array containing ids of each token being transferred (order and length must match values array)
@param values An array containing amounts of each token being transferred (order and length must match ids array)
@param data Additional data with no specified format
@return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
*/
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
)
external
returns(bytes4);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../IERC1155Upgradeable.sol";
/**
* @dev Interface of the optional ERC1155MetadataExtension interface, as defined
* in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
*
* _Available since v3.1._
*/
interface IERC1155MetadataURIUpgradeable is IERC1155Upgradeable {
/**
* @dev Returns the URI for token type `id`.
*
* If the `\{id\}` substring is present in the URI, it must be replaced by
* clients with the actual token type ID.
*/
function uri(uint256 id) external view returns (string memory);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @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) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @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");
(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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
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
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal initializer {
__ERC165_init_unchained();
}
function __ERC165_init_unchained() internal initializer {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165Upgradeable {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
function __Pausable_init() internal initializer {
__Context_init_unchained();
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal initializer {
_paused = false;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
/**
* @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
*/
interface IAccessControlEnumerableUpgradeable is IAccessControlUpgradeable {
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) external view returns (address);
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) external view returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it.
*/
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
function __AccessControl_init() internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__AccessControl_init_unchained();
}
function __AccessControl_init_unchained() internal initializer {
}
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with a standardized message including the required role.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*
* _Available since v4.1._
*/
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members[account];
}
/**
* @dev Revert with a standard message if `account` is missing `role`.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*/
function _checkRole(bytes32 role, address account) internal view {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
StringsUpgradeable.toHexString(uint160(account), 20),
" is missing role ",
StringsUpgradeable.toHexString(uint256(role), 32)
)
)
);
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) private {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*/
library EnumerableSetUpgradeable {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControlUpgradeable {
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {AccessControl-_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
| * @dev Adaptation of OpenZeppelin's ERC20Permit/ solhint-disable-next-line var-name-mixedcase | contract RarumNFT_Permit is RarumNFT_Roles, EIP712Upgradeable {
address public tokenAddress;
mapping(address => mapping(bytes32 => bool)) internal _authorizationStates;
event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);
bytes32 private constant _PERMIT_TYPEHASH = keccak256("Permit(address owner,address operator,bool approved,bytes32 nonce,uint256 deadline)");
function permit(
address owner,
address operator,
bool approved,
bytes32 nonce,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public onlyOperator {
require(block.timestamp <= deadline, "RarumNFT_Permit: expired deadline");
require(
!_authorizationStates[owner][nonce],
"RarumNFT_Permit: authorization is used"
);
bytes32 structHash = keccak256(
abi.encode(
_PERMIT_TYPEHASH,
owner,
operator,
approved,
nonce,
deadline
)
);
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSAUpgradeable.recover(hash, v, r, s);
require(signer == owner, "RarumNFT_Permit: invalid signature");
_authorizationStates[owner][nonce] = true;
_setApprovalForAll(owner, operator, approved);
emit AuthorizationUsed(owner, nonce);
}
function _setApprovalForAll(address owner, address operator, bool approved) internal {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function authorizationState(address authorizer, bytes32 nonce)
external
view
returns (bool)
{
return _authorizationStates[authorizer][nonce];
}
function DOMAIN_SEPARATOR() external view returns (bytes32) {
return _domainSeparatorV4();
}
}
| 5,420,752 | [
1,
13716,
367,
434,
3502,
62,
881,
84,
292,
267,
1807,
4232,
39,
3462,
9123,
305,
19,
3704,
11317,
17,
8394,
17,
4285,
17,
1369,
569,
17,
529,
17,
19562,
3593,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
534,
297,
379,
50,
4464,
67,
9123,
305,
353,
534,
297,
379,
50,
4464,
67,
6898,
16,
512,
2579,
27,
2138,
10784,
429,
288,
203,
203,
565,
1758,
1071,
1147,
1887,
31,
203,
203,
565,
2874,
12,
2867,
516,
2874,
12,
3890,
1578,
516,
1426,
3719,
2713,
389,
12218,
7629,
31,
203,
203,
565,
871,
10234,
6668,
12,
2867,
8808,
16761,
16,
1731,
1578,
8808,
7448,
1769,
203,
203,
565,
1731,
1578,
3238,
5381,
389,
3194,
6068,
67,
2399,
15920,
273,
417,
24410,
581,
5034,
2932,
9123,
305,
12,
2867,
3410,
16,
2867,
3726,
16,
6430,
20412,
16,
3890,
1578,
7448,
16,
11890,
5034,
14096,
2225,
1769,
203,
203,
565,
445,
21447,
12,
203,
3639,
1758,
3410,
16,
203,
3639,
1758,
3726,
16,
203,
3639,
1426,
20412,
16,
203,
3639,
1731,
1578,
7448,
16,
203,
3639,
2254,
5034,
14096,
16,
203,
3639,
2254,
28,
331,
16,
203,
3639,
1731,
1578,
436,
16,
203,
3639,
1731,
1578,
272,
203,
203,
565,
262,
1071,
1338,
5592,
288,
203,
3639,
2583,
12,
2629,
18,
5508,
1648,
14096,
16,
315,
54,
297,
379,
50,
4464,
67,
9123,
305,
30,
7708,
14096,
8863,
203,
3639,
2583,
12,
203,
5411,
401,
67,
12218,
7629,
63,
8443,
6362,
12824,
6487,
203,
5411,
315,
54,
297,
379,
50,
4464,
67,
9123,
305,
30,
6093,
353,
1399,
6,
203,
3639,
11272,
203,
203,
3639,
1731,
1578,
1958,
2310,
273,
417,
24410,
581,
5034,
12,
203,
5411,
24126,
18,
3015,
12,
203,
7734,
389,
3194,
6068,
67,
2399,
15920,
16,
203,
7734,
3410,
2
] |
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;
import {WadRayMath} from "./WadRayMath.sol";
import {AccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
import {PolicyPoolComponent} from "./PolicyPoolComponent.sol";
import {IRiskModule} from "../interfaces/IRiskModule.sol";
import {IPolicyPoolConfig} from "../interfaces/IPolicyPoolConfig.sol";
import {Policy} from "./Policy.sol";
/**
* @title Ensuro Risk Module base contract
* @dev Risk Module that keeps the configuration and is responsible for pricing and policy resolution
* @custom:security-contact [email protected]
* @author Ensuro
*/
abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoolComponent {
using Policy for Policy.PolicyData;
using WadRayMath for uint256;
// For parameters that can be changed by the risk module provider
bytes32 public constant RM_PROVIDER_ROLE = keccak256("RM_PROVIDER_ROLE");
string private _name;
uint256 internal _scrPercentage; // in ray - Solvency Capital Requirement percentage, to calculate
// capital requirement as % of (payout - premium)
uint256 internal _moc; // in ray - Margin Of Conservativism - factor that multiplies lossProb
// to calculate purePremium
uint256 internal _ensuroFee; // in ray - % of pure premium that will go for Ensuro treasury
uint256 internal _scrInterestRate; // in ray - % of interest to charge for the SCR
uint256 internal _maxScrPerPolicy; // in wad - Max SCR per policy
uint256 internal _scrLimit; // in wad - Max SCR to be allocated to this module
uint256 internal _totalScr; // in wad - Current SCR allocated to this module
address internal _wallet; // Address of the RiskModule provider
modifier validateParamsAfterChange() {
_;
_validateParameters();
}
/// @custom:oz-upgrades-unsafe-allow constructor
// solhint-disable-next-line no-empty-blocks
constructor(IPolicyPool policyPool_) PolicyPoolComponent(policyPool_) {}
/**
* @dev Initializes the RiskModule
* @param name_ Name of the Risk Module
* @param scrPercentage_ Solvency Capital Requirement percentage, to calculate
capital requirement as % of (payout - premium) (in ray)
* @param ensuroFee_ % of pure premium that will go for Ensuro treasury (in ray)
* @param scrInterestRate_ % of interest to charge for the SCR (in ray)
* @param maxScrPerPolicy_ Max SCR to be allocated to this module (in wad)
* @param scrLimit_ Max SCR to be allocated to this module (in wad)
* @param wallet_ Address of the RiskModule provider
*/
// solhint-disable-next-line func-name-mixedcase
function __RiskModule_init(
string memory name_,
uint256 scrPercentage_,
uint256 ensuroFee_,
uint256 scrInterestRate_,
uint256 maxScrPerPolicy_,
uint256 scrLimit_,
address wallet_
) internal initializer {
__AccessControl_init();
__PolicyPoolComponent_init();
__RiskModule_init_unchained(
name_,
scrPercentage_,
ensuroFee_,
scrInterestRate_,
maxScrPerPolicy_,
scrLimit_,
wallet_
);
}
// solhint-disable-next-line func-name-mixedcase
function __RiskModule_init_unchained(
string memory name_,
uint256 scrPercentage_,
uint256 ensuroFee_,
uint256 scrInterestRate_,
uint256 maxScrPerPolicy_,
uint256 scrLimit_,
address wallet_
) internal initializer {
_name = name_;
_scrPercentage = scrPercentage_;
_moc = WadRayMath.RAY;
_ensuroFee = ensuroFee_;
_scrInterestRate = scrInterestRate_;
_maxScrPerPolicy = maxScrPerPolicy_;
_scrLimit = scrLimit_;
_totalScr = 0;
_wallet = wallet_;
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_validateParameters();
}
// runs validation on RiskModule parameters
function _validateParameters() internal view {
require(
_scrPercentage <= WadRayMath.RAY && _scrPercentage > 0,
"Validation: scrPercentage must be <=1"
);
require(
_moc <= (2 * WadRayMath.RAY) && _moc >= (WadRayMath.RAY / 2),
"Validation: moc must be [0.5, 2]"
);
require(_ensuroFee <= WadRayMath.RAY, "Validation: ensuroFee must be <= 1");
require(_scrInterestRate <= WadRayMath.RAY, "Validation: scrInterestRate must be <= 1 (100%)");
// _maxScrPerPolicy no limits
require(_scrLimit >= _totalScr, "Validation: scrLimit can't be less than actual totalScr");
require(_wallet != address(0), "Validation: Wallet can't be zero address");
}
function name() public view override returns (string memory) {
return _name;
}
function scrPercentage() public view override returns (uint256) {
return _scrPercentage;
}
function moc() public view override returns (uint256) {
return _moc;
}
function ensuroFee() public view override returns (uint256) {
return _ensuroFee;
}
function scrInterestRate() public view override returns (uint256) {
return _scrInterestRate;
}
function maxScrPerPolicy() public view override returns (uint256) {
return _maxScrPerPolicy;
}
function scrLimit() public view override returns (uint256) {
return _scrLimit;
}
function totalScr() public view override returns (uint256) {
return _totalScr;
}
function wallet() public view override returns (address) {
return _wallet;
}
function setScrPercentage(uint256 newScrPercentage)
external
onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
validateParamsAfterChange
{
bool tweak = !hasPoolRole(LEVEL2_ROLE);
require(
!tweak || _isTweakRay(_scrPercentage, newScrPercentage, 1e26),
"Tweak exceeded: scrPercentage tweaks only up to 10%"
);
_scrPercentage = newScrPercentage;
_parameterChanged(
IPolicyPoolConfig.GovernanceActions.setScrPercentage,
newScrPercentage,
tweak
);
}
function setMoc(uint256 newMoc)
external
onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
validateParamsAfterChange
{
bool tweak = !hasPoolRole(LEVEL2_ROLE);
require(!tweak || _isTweakRay(_moc, newMoc, 1e26), "Tweak exceeded: moc tweaks only up to 10%");
_moc = newMoc;
_parameterChanged(IPolicyPoolConfig.GovernanceActions.setMoc, newMoc, tweak);
}
function setScrInterestRate(uint256 newScrInterestRate)
external
onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
validateParamsAfterChange
{
bool tweak = !hasPoolRole(LEVEL2_ROLE);
require(
!tweak || _isTweakRay(_scrInterestRate, newScrInterestRate, 3e26),
"Tweak exceeded: scrInterestRate tweaks only up to 30%"
);
_scrInterestRate = newScrInterestRate;
_parameterChanged(
IPolicyPoolConfig.GovernanceActions.setScrInterestRate,
newScrInterestRate,
tweak
);
}
function setEnsuroFee(uint256 newEnsuroFee)
external
onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
validateParamsAfterChange
{
bool tweak = !hasPoolRole(LEVEL2_ROLE);
require(
!tweak || _isTweakRay(_ensuroFee, newEnsuroFee, 3e26),
"Tweak exceeded: ensuroFee tweaks only up to 30%"
);
_ensuroFee = newEnsuroFee;
_parameterChanged(IPolicyPoolConfig.GovernanceActions.setEnsuroFee, newEnsuroFee, tweak);
}
function setMaxScrPerPolicy(uint256 newMaxScrPerPolicy)
external
onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
validateParamsAfterChange
{
bool tweak = !hasPoolRole(LEVEL2_ROLE);
require(
!tweak || _isTweakWad(_maxScrPerPolicy, newMaxScrPerPolicy, 3e17),
"Tweak exceeded: maxScrPerPolicy tweaks only up to 30%"
);
_maxScrPerPolicy = newMaxScrPerPolicy;
_parameterChanged(
IPolicyPoolConfig.GovernanceActions.setMaxScrPerPolicy,
newMaxScrPerPolicy,
tweak
);
}
function setScrLimit(uint256 newScrLimit)
external
onlyPoolRole3(LEVEL1_ROLE, LEVEL2_ROLE, LEVEL3_ROLE)
validateParamsAfterChange
{
bool tweak = !hasPoolRole(LEVEL2_ROLE) && !hasPoolRole(LEVEL1_ROLE);
require(
!tweak || _isTweakWad(_scrLimit, newScrLimit, 1e17),
"Tweak exceeded: scrLimit tweaks only up to 10%"
);
require(
newScrLimit <= _scrLimit ||
hasPoolRole(LEVEL1_ROLE) ||
_policyPool.totalETokenSupply().wadMul(1e17) > newScrLimit,
"Tweak exceeded: Increase, >=10% of the total liquidity, requires LEVEL1_ROLE"
);
require(newScrLimit >= _totalScr, "Can't set SCR less than current SCR allocation");
_scrLimit = newScrLimit;
_parameterChanged(IPolicyPoolConfig.GovernanceActions.setScrLimit, newScrLimit, tweak);
}
function setWallet(address wallet_)
external
onlyRole(RM_PROVIDER_ROLE)
validateParamsAfterChange
{
_wallet = wallet_;
_parameterChanged(
IPolicyPoolConfig.GovernanceActions.setWallet,
uint256(uint160(wallet_)),
false
);
}
function _newPolicy(
uint256 payout,
uint256 premium,
uint256 lossProb,
uint40 expiration,
address customer
) internal whenNotPaused returns (Policy.PolicyData memory) {
require(premium < payout, "Premium must be less than payout");
require(expiration > uint40(block.timestamp), "Expiration must be in the future");
require(customer != address(0), "Customer can't be zero address");
require(
_policyPool.currency().allowance(customer, address(_policyPool)) >= premium,
"You must allow ENSURO to transfer the premium"
);
Policy.PolicyData memory policy = Policy.initialize(
this,
premium,
payout,
lossProb,
expiration
);
require(policy.scr <= _maxScrPerPolicy, "RiskModule: SCR is more than maximum per policy");
_totalScr += policy.scr;
require(_totalScr <= _scrLimit, "RiskModule: SCR limit exceeded");
uint256 policyId = _policyPool.newPolicy(policy, customer);
policy.id = policyId;
return policy;
}
}
| @param ensuroFee_ % of pure premium that will go for Ensuro treasury (in ray) @param scrInterestRate_ % of interest to charge for the SCR (in ray) @param maxScrPerPolicy_ Max SCR to be allocated to this module (in wad) @param scrLimit_ Max SCR to be allocated to this module (in wad) @param wallet_ Address of the RiskModule provider/ solhint-disable-next-line func-name-mixedcase | function __RiskModule_init(
string memory name_,
uint256 scrPercentage_,
uint256 ensuroFee_,
uint256 scrInterestRate_,
uint256 maxScrPerPolicy_,
uint256 scrLimit_,
address wallet_
) internal initializer {
__AccessControl_init();
__PolicyPoolComponent_init();
__RiskModule_init_unchained(
name_,
scrPercentage_,
ensuroFee_,
scrInterestRate_,
maxScrPerPolicy_,
scrLimit_,
wallet_
);
}
| 12,625,500 | [
1,
773,
19321,
14667,
67,
738,
434,
16618,
23020,
5077,
716,
903,
1960,
364,
1374,
10050,
83,
9787,
345,
22498,
261,
267,
14961,
13,
225,
11991,
29281,
4727,
67,
738,
434,
16513,
358,
13765,
364,
326,
348,
5093,
261,
267,
14961,
13,
225,
943,
1541,
86,
2173,
2582,
67,
4238,
348,
5093,
358,
506,
11977,
358,
333,
1605,
261,
267,
341,
361,
13,
225,
11991,
3039,
67,
4238,
348,
5093,
358,
506,
11977,
358,
333,
1605,
261,
267,
341,
361,
13,
225,
9230,
67,
5267,
434,
326,
534,
10175,
3120,
2893,
19,
3704,
11317,
17,
8394,
17,
4285,
17,
1369,
1326,
17,
529,
17,
19562,
3593,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
225,
445,
1001,
54,
10175,
3120,
67,
2738,
12,
203,
565,
533,
3778,
508,
67,
16,
203,
565,
2254,
5034,
11991,
16397,
67,
16,
203,
565,
2254,
5034,
570,
10050,
83,
14667,
67,
16,
203,
565,
2254,
5034,
11991,
29281,
4727,
67,
16,
203,
565,
2254,
5034,
943,
1541,
86,
2173,
2582,
67,
16,
203,
565,
2254,
5034,
11991,
3039,
67,
16,
203,
565,
1758,
9230,
67,
203,
225,
262,
2713,
12562,
288,
203,
565,
1001,
16541,
67,
2738,
5621,
203,
565,
1001,
2582,
2864,
1841,
67,
2738,
5621,
203,
565,
1001,
54,
10175,
3120,
67,
2738,
67,
4384,
8707,
12,
203,
1377,
508,
67,
16,
203,
1377,
11991,
16397,
67,
16,
203,
1377,
570,
10050,
83,
14667,
67,
16,
203,
1377,
11991,
29281,
4727,
67,
16,
203,
1377,
943,
1541,
86,
2173,
2582,
67,
16,
203,
1377,
11991,
3039,
67,
16,
203,
1377,
9230,
67,
203,
565,
11272,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity ^0.4.24;
//==============================================================================
// _ _ _ _|_ _ .
// (/_\/(/_| | | _\ .
//==============================================================================
contract F3Devents {
// fired whenever a player registers a name
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
// fired at end of buy or reload
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
// fired whenever theres a withdraw
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
// fired whenever a withdraw forces end round to be ran
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
// (fomo3d long only) fired whenever a player tries a buy after round timer
// hit zero, and causes end round to be ran.
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
// (fomo3d long only) fired whenever a player tries a reload after round timer
// hit zero, and causes end round to be ran.
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
// fired whenever an affiliate is paid
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
// // received pot swap deposit
// event onPotSwapDeposit
// (
// uint256 roundID,
// uint256 amountAddedToPot
// );
}
//==============================================================================
// _ _ _ _|_ _ _ __|_ _ _ _|_ _ .
// (_(_)| | | | (_|(_ | _\(/_ | |_||_) .
//====================================|=========================================
contract modularLong is F3Devents {}
contract FoMo3Dlong is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
//god of game
address constant private god = 0xe1B35fEBaB9Ff6da5b29C3A7A44eef06cD86B0f9;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x99a1cac09c1c07037c3c7b821ce4ddc4a9fe564d);
//==============================================================================
// _ _ _ |`. _ _ _ |_ | _ _ .
// (_(_)| |~|~|(_||_|| (_||_)|(/__\ . (game settings)
//=================_|===========================================================
string constant public name = "FM3D More Award~";
string constant public symbol = "F3D";
uint256 private rndExtra_ = 10 minutes; // length of the very first ICO
uint256 private rndGap_ = 30 minutes; // length of ICO phase, set to 1 year for EOS.
uint256 constant private rndInit_ = 1 hours; // round timer starts at this
uint256 constant private rndInc_ = 30 seconds; // every full key purchased adds this much to the timer
uint256 constant private rndMax_ = 8 hours; // max length a round timer can be
//==============================================================================
// _| _ _|_ _ _ _ _|_ _ .
// (_|(_| | (_| _\(/_ | |_||_) . (data used to store game info that changes)
//=============================|================================================
uint256 public airDropPot_; // person who gets the airdrop wins part of this pot
uint256 public airDropTracker_ = 0; // incremented each time a "qualified" tx occurs. used to determine winning air drop
uint256 public rID_; // round id number / total rounds that have happened
//****************
// PLAYER DATA
//****************
mapping (address => uint256) public pIDxAddr_; // (addr => pID) returns player id by address
mapping (bytes32 => uint256) public pIDxName_; // (name => pID) returns player id by name
mapping (uint256 => F3Ddatasets.Player) public plyr_; // (pID => data) player data
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; // (pID => rID => data) player round data by player id & round id
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; // (pID => name => bool) list of names a player owns. (used so you can change your display name amongst any name you own)
//****************
// ROUND DATA
//****************
mapping (uint256 => F3Ddatasets.Round) public round_; // (rID => data) round data
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; // (rID => tID => data) eth in per team, by round id and team id
//****************
// TEAM FEE DATA
//****************
mapping (uint256 => F3Ddatasets.TeamFee) public fees_; // (team => fees) fee distribution by team
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_; // (team => fees) pot split distribution by team
//==============================================================================
// _ _ _ __|_ _ __|_ _ _ .
// (_(_)| |_\ | | |_|(_ | (_)| . (initial data setup upon contract deploy)
//==============================================================================
constructor()
public
{
// Team allocation percentages
fees_[0] = F3Ddatasets.TeamFee(40,0); //40% to gen, 20% to pot, 35% to aff, 5% to com, 0% to air drop pot
fees_[1] = F3Ddatasets.TeamFee(40,0); //40% to gen, 20% to pot, 35% to aff, 5% to com, 0% to air drop pot
fees_[2] = F3Ddatasets.TeamFee(40,0); //40% to gen, 20% to pot, 35% to aff, 5% to com, 0% to air drop pot
fees_[3] = F3Ddatasets.TeamFee(40,0); //40% to gen, 20% to pot, 35% to aff, 5% to com, 0% to air drop pot
potSplit_[0] = F3Ddatasets.PotSplit(95,0); //95% to winner, 5% to next round, 0% to com
potSplit_[1] = F3Ddatasets.PotSplit(95,0); //95% to winner, 5% to next round, 0% to com
potSplit_[2] = F3Ddatasets.PotSplit(95,0); //95% to winner, 5% to next round, 0% to com
potSplit_[3] = F3Ddatasets.PotSplit(95,0); //95% to winner, 5% to next round, 0% to com
}
//==============================================================================
// _ _ _ _|. |`. _ _ _ .
// | | |(_)(_||~|~|(/_| _\ . (these are safety checks)
//==============================================================================
/**
* @dev used to make sure no one can interact with contract until it has
* been activated.
*/
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
/**
* @dev prevents contracts from interacting with fomo3d
*/
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
/**
* @dev sets boundaries for incoming tx
*/
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
//==============================================================================
// _ |_ |. _ |` _ __|_. _ _ _ .
// |_)|_||_)||(_ ~|~|_|| |(_ | |(_)| |_\ . (use these to interact with contract)
//====|=========================================================================
/**
* @dev emergency buy uses last stored affiliate ID and team snek
*/
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
// set up our tx event data and determine if player is new or not
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// buy core
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
/**
* @dev determine player's affid
* @param _pID the ID/address/name of the player who gets the affiliate fee
* @param _inAffID what team is the player playing for?
* @return _affID player's real affid
*/
function determineAffID(uint256 _pID, uint256 _inAffID) private returns(uint256){
if(plyr_[_pID].laff == 0){
// update last affiliate
plyr_[_pID].laff = _inAffID;
}
return plyr_[_pID].laff;
}
/**
* @dev converts all incoming ethereum to keys.
* -functionhash- 0x8f38f309 (using ID for affiliate)
* -functionhash- 0x98a0871d (using address for affiliate)
* -functionhash- 0xa65b37a1 (using name for affiliate)
* @param _affCode the ID/address/name of the player who gets the affiliate fee
* @param _team what team is the player playing for?
*/
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
// set up our tx event data and determine if player is new or not
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == 0 || _affCode == _pID)
{
// use last stored affiliate code
_affCode = plyr_[_pID].laff;
// if affiliate code was given & its not the same as previously stored
} else if (_affCode != plyr_[_pID].laff) {
_affCode = determineAffID(_pID,_affCode);
}
// verify a valid team was selected
_team = verifyTeam(_team);
// buy core
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
// set up our tx event data and determine if player is new or not
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
uint256 _affID;
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == address(0) || _affCode == msg.sender)
{
// use last stored affiliate code
_affID = plyr_[_pID].laff;
// if affiliate code was given
} else {
// get affiliate ID from aff Code
_affID = pIDxAddr_[_affCode];
// if affID is not the same as previously stored
if (_affID != plyr_[_pID].laff)
{
_affID = determineAffID(_pID,_affID);
}
}
// verify a valid team was selected
_team = verifyTeam(_team);
// buy core
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
// set up our tx event data and determine if player is new or not
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
uint256 _affID;
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
// use last stored affiliate code
_affID = plyr_[_pID].laff;
// if affiliate code was given
} else {
// get affiliate ID from aff Code
_affID = pIDxName_[_affCode];
// if affID is not the same as previously stored
if (_affID != plyr_[_pID].laff)
{
_affID = determineAffID(_pID,_affID);
}
}
// verify a valid team was selected
_team = verifyTeam(_team);
// buy core
buyCore(_pID, _affID, _team, _eventData_);
}
/**
* @dev essentially the same as buy, but instead of you sending ether
* from your wallet, it uses your unwithdrawn earnings.
* -functionhash- 0x349cdcac (using ID for affiliate)
* -functionhash- 0x82bfc739 (using address for affiliate)
* -functionhash- 0x079ce327 (using name for affiliate)
* @param _affCode the ID/address/name of the player who gets the affiliate fee
* @param _team what team is the player playing for?
* @param _eth amount of earnings to use (remainder returned to gen vault)
*/
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
// set up our tx event data
F3Ddatasets.EventReturns memory _eventData_;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == 0 || _affCode == _pID)
{
// use last stored affiliate code
_affCode = plyr_[_pID].laff;
// if affiliate code was given & its not the same as previously stored
} else if (_affCode != plyr_[_pID].laff) {
_affCode = determineAffID(_pID,_affCode);
}
// verify a valid team was selected
_team = verifyTeam(_team);
// reload core
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
// set up our tx event data
F3Ddatasets.EventReturns memory _eventData_;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
uint256 _affID;
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == address(0) || _affCode == msg.sender)
{
// use last stored affiliate code
_affID = plyr_[_pID].laff;
// if affiliate code was given
} else {
// get affiliate ID from aff Code
_affID = pIDxAddr_[_affCode];
// if affID is not the same as previously stored
if (_affID != plyr_[_pID].laff)
{
_affID = determineAffID(_pID,_affID);
}
}
// verify a valid team was selected
_team = verifyTeam(_team);
// reload core
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
// set up our tx event data
F3Ddatasets.EventReturns memory _eventData_;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
uint256 _affID;
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
// use last stored affiliate code
_affID = plyr_[_pID].laff;
// if affiliate code was given
} else {
// get affiliate ID from aff Code
_affID = pIDxName_[_affCode];
// if affID is not the same as previously stored
if (_affID != plyr_[_pID].laff)
{
_affID = determineAffID(_pID,_affID);
}
}
// verify a valid team was selected
_team = verifyTeam(_team);
// reload core
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
/**
* @dev withdraws all of your earnings.
* -functionhash- 0x3ccfd60b
*/
function withdraw()
isActivated()
isHuman()
public
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// setup temp var for player eth
uint256 _eth;
// check to see if round has ended and no one has run round end yet
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
// set up our tx event data
F3Ddatasets.EventReturns memory _eventData_;
// end the round (distributes pot)
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
// get their earnings
_eth = withdrawEarnings(_pID);
// gib moni
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
// build event data
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
// fire withdraw and distribute event
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
// in any other situation
} else {
// get their earnings
_eth = withdrawEarnings(_pID);
// gib moni
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
// fire withdraw event
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
/**
* @dev use these to register names. they are just wrappers that will send the
* registration requests to the PlayerBook contract. So registering here is the
* same as registering there. UI will always display the last name you registered.
* but you will still own all previously registered names to use as affiliate
* links.
* - must pay a registration fee.
* - name must be unique
* - names will be converted to lowercase
* - name cannot start or end with a space
* - cannot have more than 1 space in a row
* - cannot be only numbers
* - cannot start with 0x
* - name must be at least 1 char
* - max length of 32 characters long
* - allowed characters: a-z, 0-9, and space
* -functionhash- 0x921dec21 (using ID for affiliate)
* -functionhash- 0x3ddd4698 (using address for affiliate)
* -functionhash- 0x685ffd83 (using name for affiliate)
* @param _nameString players desired name
* @param _affCode affiliate ID, address, or name of who referred you
* @param _all set to true if you want this to push your info to all games
* (this might cost a lot of gas)
*/
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
// fire event
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
// fire event
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
// fire event
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
//==============================================================================
// _ _ _|__|_ _ _ _ .
// (_|(/_ | | (/_| _\ . (for UI & viewing things on etherscan)
//=====_|=======================================================================
/**
* @dev return the price buyer will pay for next 1 individual key.
* -functionhash- 0x018a25e8
* @return price for next key bought (in wei format)
*/
function getBuyPrice()
public
view
returns(uint256)
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// are we in a round?
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else // rounds over. need price for new round
return ( 75000000000000 ); // init
}
/**
* @dev returns time left. dont spam this, you'll ddos yourself from your node
* provider
* -functionhash- 0xc7e284b8
* @return time left in seconds
*/
function getTimeLeft()
public
view
returns(uint256)
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
/**
* @dev returns player earnings per vaults
* -functionhash- 0x63066434
* @return winnings vault
* @return general vault
* @return affiliate vault
*/
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
// setup local rID
uint256 _rID = rID_;
// if round has ended. but round end has not been run (so contract has not distributed winnings)
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
// if player is winner
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
// if player is not the winner
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
// if round is still going on, or round has ended and round end has been ran
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
/**
* solidity hates stack limits. this lets us avoid that hate
*/
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
/**
* @dev returns all current round info needed for front end
* -functionhash- 0x747dff42
* @return eth invested during ICO phase
* @return round id
* @return total keys for round
* @return time round ends
* @return time round started
* @return current pot
* @return current team ID & player ID in lead
* @return current player in leads address
* @return current player in leads name
* @return whales eth in for round
* @return bears eth in for round
* @return sneks eth in for round
* @return bulls eth in for round
* @return airdrop tracker # & airdrop pot
*/
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
// setup local rID
uint256 _rID = rID_;
return
(
round_[_rID].ico, //0
_rID, //1
round_[_rID].keys, //2
round_[_rID].end, //3
round_[_rID].strt, //4
round_[_rID].pot, //5
(round_[_rID].team + (round_[_rID].plyr * 10)), //6
plyr_[round_[_rID].plyr].addr, //7
plyr_[round_[_rID].plyr].name, //8
rndTmEth_[_rID][0], //9
rndTmEth_[_rID][1], //10
rndTmEth_[_rID][2], //11
rndTmEth_[_rID][3], //12
airDropTracker_ + (airDropPot_ * 1000) //13
);
}
/**
* @dev returns player info based on address. if no address is given, it will
* use msg.sender
* -functionhash- 0xee0b5d8b
* @param _addr address of the player you want to lookup
* @return player ID
* @return player name
* @return keys owned (current round)
* @return winnings vault
* @return general vault
* @return affiliate vault
* @return player round eth
*/
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
// setup local rID
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID, //0
plyr_[_pID].name, //1
plyrRnds_[_pID][_rID].keys, //2
plyr_[_pID].win, //3
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), //4
plyr_[_pID].aff, //5
plyrRnds_[_pID][_rID].eth //6
);
}
//==============================================================================
// _ _ _ _ | _ _ . _ .
// (_(_)| (/_ |(_)(_||(_ . (this + tools + calcs + modules = our softwares engine)
//=====================_|=======================================================
/**
* @dev logic runs whenever a buy order is executed. determines how to handle
* incoming eth depending on if we are in an active round or not
*/
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// if round is active
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
// call core
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
// if round is not active
} else {
// check to see if end round needs to be ran
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
// end the round (distributes pot) & start new round
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
// build event data
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
// fire buy and distribute event
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
// put eth in players vault
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
/**
* @dev logic runs whenever a reload order is executed. determines how to handle
* incoming eth depending on if we are in an active round or not
*/
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// if round is active
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
// get earnings from all vaults and return unused to gen vault
// because we use a custom safemath library. this will throw if player
// tried to spend more eth than they have.
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
// call core
core(_rID, _pID, _eth, _affID, _team, _eventData_);
// if round is not active and end round needs to be ran
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
// end the round (distributes pot) & start new round
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
// build event data
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
// fire buy and distribute event
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
/**
* @dev this is the core logic for any buy/reload that happens while a round
* is live.
*/
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
// if player is new to round
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
// // early round eth limiter
// if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
// {
// uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
// uint256 _refund = _eth.sub(_availableLimit);
// plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
// _eth = _availableLimit;
// }
// if eth left is greater than min eth allowed (sorry no pocket lint)
if (_eth > 1000000000)
{
// mint the new keys
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
// if they bought at least 1 whole key
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
// set new leaders
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
// set the new leader bool to true
_eventData_.compressedData = _eventData_.compressedData + 100;
}
// manage airdrops
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
// gib muni
uint256 _prize;
if (_eth >= 10000000000000000000)
{
// calculate prize and give it to winner
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
// adjust airDropPot
airDropPot_ = (airDropPot_).sub(_prize);
// let event know a tier 3 prize was won
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
// calculate prize and give it to winner
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
// adjust airDropPot
airDropPot_ = (airDropPot_).sub(_prize);
// let event know a tier 2 prize was won
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
// calculate prize and give it to winner
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
// adjust airDropPot
airDropPot_ = (airDropPot_).sub(_prize);
// let event know a tier 3 prize was won
_eventData_.compressedData += 300000000000000000000000000000000;
}
// set airdrop happened bool to true
_eventData_.compressedData += 10000000000000000000000000000000;
// let event know how much was won
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
// reset air drop tracker
airDropTracker_ = 0;
}
}
// store the air drop tracker number (number of buys since last airdrop)
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
// update player
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
// update round
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
// distribute eth
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
// call end tx function to fire end tx event.
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
//==============================================================================
// _ _ | _ | _ _|_ _ _ _ .
// (_(_||(_|_||(_| | (_)| _\ .
//==============================================================================
/**
* @dev calculates unmasked earnings (just calculates, does not update mask)
* @return earnings in wei format
*/
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
/**
* @dev returns the amount of keys you would get given an amount of eth.
* -functionhash- 0xce89c80c
* @param _rID round ID you want price for
* @param _eth amount of eth sent in
* @return keys received
*/
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
// grab time
uint256 _now = now;
// are we in a round?
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else // rounds over. need keys for new round
return ( (_eth).keys() );
}
/**
* @dev returns current eth price for X keys.
* -functionhash- 0xcf808000
* @param _keys number of keys desired (in 18 decimal format)
* @return amount of eth needed to send
*/
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// are we in a round?
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else // rounds over. need price for new round
return ( (_keys).eth() );
}
//==============================================================================
// _|_ _ _ | _ .
// | (_)(_)|_\ .
//==============================================================================
/**
* @dev receives name/player info from names contract
*/
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
/**
* @dev receives entire player name list
*/
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
/**
* @dev gets existing or registers new pID. use this when a player may be new
* @return pID
*/
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
// if player is new to this version of fomo3d
if (_pID == 0)
{
// grab their player ID, name and last aff ID, from player names contract
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
// set up player account
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
// set the new player bool to true
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
/**
* @dev checks to make sure user picked a valid team. if not sets team
* to default (sneks)
*/
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
/**
* @dev decides if round end needs to be run & new round started. and if
* player unmasked earnings from previously played rounds need to be moved.
*/
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
// if player has played a previous round, move their unmasked earnings
// from that round to gen vault.
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
// update player's last round played
plyr_[_pID].lrnd = rID_;
// set the joined round bool to true
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
/**
* @dev ends the round. manages paying out winner/splitting up pot
*/
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
// setup local rID
uint256 _rID = rID_;
// grab our winning player and team id's
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
// grab our pot amount
uint256 _pot = round_[_rID].pot;
// calculate our winner share, community rewards, gen share,
// p3d share, and amount reserved for next pot
uint256 _win = (_pot.mul(95)) / 100;
uint256 _com = 0; //(_pot / 10);
uint256 _gen = 0; //(_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = 0; //(_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
// calculate ppt for round mask
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
// pay our winner
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
// // community rewards
// if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
// {
// // This ensures Team Just cannot influence the outcome of FoMo3D with
// // bank migrations by breaking outgoing transactions.
// // Something we would never do. But that's not the point.
// // We spent 2000$ in eth re-deploying just to patch this, we hold the
// // highest belief that everything we create should be trustless.
// // Team JUST, The name you shouldn't have to trust.
// _p3d = _p3d.add(_com);
// _com = 0;
// }
// // community rewards send to god
// address(god).transfer(_com);
// distribute gen portion to key holders
round_[_rID].mask = _ppt.add(round_[_rID].mask);
// // send share for p3d to divies
// if (_p3d > 0)
// address(god).transfer(_p3d); //Divies.deposit.value(_p3d)();
// prepare event data
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
// start next round
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
/**
* @dev moves any unmasked earnings to gen vault. updates earnings mask
*/
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
// put in gen vault
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
// zero out their earnings by updating mask
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
/**
* @dev updates round timer based on number of whole keys bought.
*/
function updateTimer(uint256 _keys, uint256 _rID)
private
{
// grab time
uint256 _now = now;
// calculate time based on number of keys bought
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
// compare to max and set new end time
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
/**
* @dev generates a random number between 0-99 and checks to see if thats
* resulted in an airdrop win
* @return do we have a winner?
*/
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
/**
* @dev distributes eth based on fees to com, aff, and p3d
*/
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
// pay 5% out to community rewards
uint256 _com = _eth / 20;
uint256 _p3d;
// if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
// {
// // This ensures Team Just cannot influence the outcome of FoMo3D with
// // bank migrations by breaking outgoing transactions.
// // Something we would never do. But that's not the point.
// // We spent 2000$ in eth re-deploying just to patch this, we hold the
// // highest belief that everything we create should be trustless.
// // Team JUST, The name you shouldn't have to trust.
// _p3d = _com;
// _com = 0;
// }
// // pay 1% out to FoMo3D short
// uint256 _long = _eth / 100;
// otherF3D_.potSwap.value(_long)();
//community rewards and FoMo3D short all send to god
address(god).transfer(_com);
// distribute share to affiliate 35%
uint256 _aff = _eth.mul(35) / (100);
// decide what to do with affiliate share of fees
// affiliate must not be self, and must have a name registered
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
// pay out p3d
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
// // deposit to divies contract
// Divies.deposit.value(_p3d)();
// // set up event data
// _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
// p3d send to god
address(god).transfer(_p3d);
}
return(_eventData_);
}
// this function had a bug~
// function potSwap()
// external
// payable
// {
// // setup local rID
// uint256 _rID = rID_ + 1;
// round_[_rID].pot = round_[_rID].pot.add(msg.value);
// emit F3Devents.onPotSwapDeposit(_rID, msg.value);
// }
/**
* @dev distributes eth based on fees to gen and pot
*/
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
// calculate gen share
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
// toss 0% into airdrop pot
uint256 _air = 0; // (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
// // update eth balance (eth = eth - (com share + pot swap share + aff share + p3d share + airdrop pot share))
// _eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
// calculate pot
uint256 _pot = (_eth.mul(20)) / 100; //_eth.sub(_gen);
// distribute gen share (thats what updateMasks() does) and adjust
// balances for dust.
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
// add eth to pot
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
// set up event data
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
/**
* @dev updates masks for round and player when keys are bought
* @return dust left over
*/
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
/* MASKING NOTES
earnings masks are a tricky thing for people to wrap their minds around.
the basic thing to understand here. is were going to have a global
tracker based on profit per share for each round, that increases in
relevant proportion to the increase in share supply.
the player will have an additional mask that basically says "based
on the rounds mask, my shares, and how much i've already withdrawn,
how much is still owed to me?"
*/
// calc profit per key & round mask based on this buy: (dust goes to pot)
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
// calculate player earning from their own buy (only based on the keys
// they just bought). & update player earnings mask
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
// calculate & return dust
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
/**
* @dev adds up unmasked earnings, & vault earnings, sets them all to 0
* @return earnings in wei format
*/
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
// update gen vault
updateGenVault(_pID, plyr_[_pID].lrnd);
// from vaults
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
/**
* @dev prepares compression data and fires event for buy or reload tx's
*/
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
//==============================================================================
// (~ _ _ _._|_ .
// _)(/_(_|_|| | | \/ .
//====================/=========================================================
/** upon contract deploy, it will be deactivated. this is a one time
* use function that will activate the contract. we do this so devs
* have time to set things up on the web end **/
bool public activated_ = false;
function activate()
public
{
// only team just can activate
// require(
// msg.sender == 0x18E90Fc6F70344f53EBd4f6070bf6Aa23e2D748C ||
// msg.sender == 0x8b4DA1827932D71759687f925D17F81Fc94e3A9D ||
// msg.sender == 0x8e0d985f3Ec1857BEc39B76aAabDEa6B31B67d53 ||
// msg.sender == 0x7ac74Fcc1a71b106F12c55ee8F802C9F672Ce40C ||
// msg.sender == 0xF39e044e1AB204460e06E87c6dca2c6319fC69E3,
// "only team just can activate"
// );
require(msg.sender == god, "only team just can activate");
// // make sure that its been linked.
// require(address(otherF3D_) != address(0), "must link to other FoMo3D first");
// can only be ran once
require(activated_ == false, "fomo3d already activated");
// activate the contract
activated_ = true;
// lets start first round
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
// function setOtherFomo(address _otherF3D)
// public
// {
// // only team just can activate
// require(
// msg.sender == 0x18E90Fc6F70344f53EBd4f6070bf6Aa23e2D748C ||
// msg.sender == 0x8b4DA1827932D71759687f925D17F81Fc94e3A9D ||
// msg.sender == 0x8e0d985f3Ec1857BEc39B76aAabDEa6B31B67d53 ||
// msg.sender == 0x7ac74Fcc1a71b106F12c55ee8F802C9F672Ce40C ||
// msg.sender == 0xF39e044e1AB204460e06E87c6dca2c6319fC69E3,
// "only team just can activate"
// );
// // make sure that it HASNT yet been linked.
// require(address(otherF3D_) == address(0), "silly dev, you already did that");
// // set up other fomo3d (fast or long) for pot swap
// otherF3D_ = otherFoMo3D(_otherF3D);
// }
}
//==============================================================================
// __|_ _ __|_ _ .
// _\ | | |_|(_ | _\ .
//==============================================================================
library F3Ddatasets {
//compressedData key
// [76-33][32][31][30][29][28-18][17][16-6][5-3][2][1][0]
// 0 - new player (bool)
// 1 - joined round (bool)
// 2 - new leader (bool)
// 3-5 - air drop tracker (uint 0-999)
// 6-16 - round end time
// 17 - winnerTeam
// 18 - 28 timestamp
// 29 - team
// 30 - 0 = reinvest (round), 1 = buy (round), 2 = buy (ico), 3 = reinvest (ico)
// 31 - airdrop happened bool
// 32 - airdrop tier
// 33 - airdrop amount won
//compressedIDs key
// [77-52][51-26][25-0]
// 0-25 - pID
// 26-51 - winPID
// 52-77 - rID
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr; // winner address
bytes32 winnerName; // winner name
uint256 amountWon; // amount won
uint256 newPot; // amount in new pot
uint256 P3DAmount; // amount distributed to p3d
uint256 genAmount; // amount distributed to gen
uint256 potAmount; // amount added to pot
}
struct Player {
address addr; // player address
bytes32 name; // player name
uint256 win; // winnings vault
uint256 gen; // general vault
uint256 aff; // affiliate vault
uint256 lrnd; // last round played
uint256 laff; // last affiliate id used
}
struct PlayerRounds {
uint256 eth; // eth player has added to round (used for eth limiter)
uint256 keys; // keys
uint256 mask; // player mask
uint256 ico; // ICO phase investment
}
struct Round {
uint256 plyr; // pID of player in lead
uint256 team; // tID of team in lead
uint256 end; // time ends/ended
bool ended; // has round end function been ran
uint256 strt; // time round started
uint256 keys; // keys
uint256 eth; // total eth in
uint256 pot; // eth to pot (during round) / final amount paid to winner (after round ends)
uint256 mask; // global mask
uint256 ico; // total eth sent in during ICO phase
uint256 icoGen; // total eth for gen during ICO phase
uint256 icoAvg; // average key price for ICO phase
}
struct TeamFee {
uint256 gen; // % of buy in thats paid to key holders of current round
uint256 p3d; // % of buy in thats paid to p3d holders
}
struct PotSplit {
uint256 gen; // % of pot thats paid to key holders of current round
uint256 p3d; // % of pot thats paid to p3d holders
}
}
//==============================================================================
// | _ _ _ | _ .
// |<(/_\/ (_(_||(_ .
//=======/======================================================================
library F3DKeysCalcLong {
using SafeMath for *;
/**
* @dev calculates number of keys received given X eth
* @param _curEth current amount of eth in contract
* @param _newEth eth being spent
* @return amount of ticket purchased
*/
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
/**
* @dev calculates amount of eth received if you sold X keys
* @param _curKeys current amount of keys that exist
* @param _sellKeys amount of keys you wish to sell
* @return amount of eth received
*/
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
/**
* @dev calculates how many keys would exist with given an amount of eth
* @param _eth eth "in contract"
* @return number of keys that would exist
*/
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
/**
* @dev calculates how much eth would be in contract given a number of keys
* @param _keys number of keys "in contract"
* @return eth that would exists
*/
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
//==============================================================================
// . _ _|_ _ _ |` _ _ _ _ .
// || | | (/_| ~|~(_|(_(/__\ .
//==============================================================================
// interface otherFoMo3D {
// function potSwap() external payable;
// }
interface F3DexternalSettingsInterface {
function getFastGap() external returns(uint256);
function getLongGap() external returns(uint256);
function getFastExtra() external returns(uint256);
function getLongExtra() external returns(uint256);
}
// interface DiviesInterface {
// function deposit() external payable;
// }
// interface JIincForwarderInterface {
// function deposit() external payable returns(bool);
// function status() external view returns(address, address, bool);
// function startMigration(address _newCorpBank) external returns(bool);
// function cancelMigration() external returns(bool);
// function finishMigration() external returns(bool);
// function setup(address _firstCorpBank) external;
// }
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
/**
* @dev filters name strings
* -converts uppercase to lower case.
* -makes sure it does not start/end with a space
* -makes sure it does not contain multiple spaces in a row
* -cannot be only numbers
* -cannot start with 0x
* -restricts characters to A-Z, a-z, 0-9, and space.
* @return reprocessed string in bytes32 format
*/
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
//sorry limited to 32 characters
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
// make sure it doesnt start with or end with space
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
// make sure first two characters are not 0x
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
// create a bool to track if we have a non number character
bool _hasNonNumber;
// convert & check
for (uint256 i = 0; i < _length; i++)
{
// if its uppercase A-Z
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
// convert to lower case a-z
_temp[i] = byte(uint(_temp[i]) + 32);
// we have a non number
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
// require character is a space
_temp[i] == 0x20 ||
// OR lowercase a-z
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
// or 0-9
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
// make sure theres not 2x spaces in a row
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
// see if we have a character other than a number
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
/**
* @title SafeMath v0.1.9
* @dev Math operations with safety checks that throw on error
* change notes: original SafeMath library from OpenZeppelin modified by Inventor
* - added sqrt
* - added sq
* - added pwr
* - changed asserts to requires with error log outputs
* - removed div, its useless
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
/**
* @dev gives square root of given x.
*/
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
/**
* @dev gives square. multiplies x by x
*/
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
/**
* @dev x to the power of y
*/
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | ============================================================================== _ _ _ _|_ _ . (/_\/(/_| | | _\ .============================================================================== fired whenever a player registers a name fired at end of buy or reload fired whenever theres a withdraw fired whenever a withdraw forces end round to be ran (fomo3d long only) fired whenever a player tries a buy after round timer hit zero, and causes end round to be ran. (fomo3d long only) fired whenever a player tries a reload after round timer hit zero, and causes end round to be ran. fired whenever an affiliate is paid received pot swap deposit event onPotSwapDeposit ( uint256 roundID, uint256 amountAddedToPot ); | contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
| 9,851,684 | [
1,
9917,
26678,
377,
389,
565,
389,
225,
389,
389,
96,
67,
389,
225,
263,
565,
261,
18510,
6700,
12,
18510,
96,
571,
571,
389,
64,
225,
263,
9917,
26678,
15950,
17334,
279,
7291,
10285,
279,
508,
15950,
622,
679,
434,
30143,
578,
7749,
15950,
17334,
286,
11737,
279,
598,
9446,
15950,
17334,
279,
598,
9446,
26376,
679,
3643,
358,
506,
18892,
261,
74,
362,
83,
23,
72,
1525,
1338,
13,
15950,
17334,
279,
7291,
9327,
279,
30143,
1839,
3643,
5441,
6800,
3634,
16,
471,
14119,
679,
3643,
358,
506,
18892,
18,
261,
74,
362,
83,
23,
72,
1525,
1338,
13,
15950,
17334,
279,
7291,
9327,
279,
7749,
1839,
3643,
5441,
6800,
3634,
16,
471,
14119,
679,
3643,
358,
506,
18892,
18,
15950,
17334,
392,
7103,
330,
3840,
353,
30591,
225,
5079,
5974,
7720,
443,
1724,
871,
603,
18411,
12521,
758,
1724,
261,
377,
2254,
5034,
3643,
734,
16,
2
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
] | [
1,
16351,
478,
23,
758,
616,
87,
288,
203,
565,
871,
603,
1908,
461,
203,
565,
261,
203,
3639,
2254,
5034,
8808,
7291,
734,
16,
203,
3639,
1758,
8808,
7291,
1887,
16,
203,
3639,
1731,
1578,
8808,
7291,
461,
16,
203,
3639,
1426,
10783,
12148,
16,
203,
3639,
2254,
5034,
7103,
330,
3840,
734,
16,
203,
3639,
1758,
7103,
330,
3840,
1887,
16,
203,
3639,
1731,
1578,
7103,
330,
3840,
461,
16,
203,
3639,
2254,
5034,
3844,
16507,
350,
16,
203,
3639,
2254,
5034,
18198,
203,
565,
11272,
203,
377,
203,
565,
871,
603,
1638,
4188,
203,
565,
261,
203,
3639,
2254,
5034,
8968,
751,
16,
1377,
203,
3639,
2254,
5034,
8968,
5103,
16,
4202,
203,
3639,
1731,
1578,
7291,
461,
16,
203,
3639,
1758,
7291,
1887,
16,
203,
3639,
2254,
5034,
13750,
382,
16,
203,
3639,
2254,
5034,
1311,
13809,
9540,
16,
203,
3639,
1758,
5657,
1224,
3178,
16,
203,
3639,
1731,
1578,
5657,
1224,
461,
16,
203,
3639,
2254,
5034,
3844,
59,
265,
16,
203,
3639,
2254,
5034,
394,
18411,
16,
203,
3639,
2254,
5034,
453,
23,
40,
6275,
16,
203,
3639,
2254,
5034,
3157,
6275,
16,
203,
3639,
2254,
5034,
5974,
6275,
16,
203,
3639,
2254,
5034,
23350,
7544,
18411,
203,
565,
11272,
203,
377,
203,
565,
871,
603,
1190,
9446,
203,
565,
261,
203,
3639,
2254,
5034,
8808,
7291,
734,
16,
203,
3639,
1758,
7291,
1887,
16,
203,
3639,
1731,
1578,
7291,
461,
16,
203,
3639,
2254,
5034,
13750,
1182,
16,
203,
3639,
2254,
5034,
18198,
203,
565,
11272,
203,
377,
2
] |
pragma solidity ^0.4.4;
import "github.com/JonnyLatte/MiscSolidity/erc20.sol";
contract sha3CollisionBounty {
address public owner;
bytes32 public A;
bytes32 public B;
function claim(bytes32 a, bytes32 b) {
if(owner != 0 ) throw; // can only be claimed once
if(a == b ) throw; // must be 2 different sets of data
if(sha3(a) != sha3(b)) throw; // must hash to the same value
A = a;
B = b;
owner = msg.sender;
}
function withdraw() {
if(owner != msg.sender) throw;
if(!owner.send(this.balance)) throw;
}
function withdrawToken(ERC20 token) {
if(owner != msg.sender) throw;
if(!token.transfer(owner,token.balanceOf(this))) throw;
}
function claimToken(ERC20 token, address target, uint256 value) {
if(owner != msg.sender) throw;
if(!token.transferFrom(target,owner,value)) throw;
}
function () payable {
}
}
| can only be claimed once
| if(owner != 0 ) throw; | 905,570 | [
1,
4169,
1338,
506,
7516,
329,
3647,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
309,
12,
8443,
480,
374,
3639,
262,
604,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/4/0x8CD301A50dFbE088F0F49d202E7CB91abb8b22fa/sources/contracts/Service.sol | check if entity is sharelimited in the collection
| if(c.collectionShareLimit > 0) require (collectionSharesByEntity[c.id][msg.sender] <= c.collectionShareLimit, "Reached max pool limit!"); | 12,269,747 | [
1,
1893,
309,
1522,
353,
7433,
21325,
316,
326,
1849,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
309,
12,
71,
18,
5548,
9535,
3039,
405,
374,
13,
2583,
261,
5548,
24051,
858,
1943,
63,
71,
18,
350,
6362,
3576,
18,
15330,
65,
1648,
276,
18,
5548,
9535,
3039,
16,
315,
23646,
943,
2845,
1800,
4442,
1769,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
/**
*Submitted for verification at Etherscan.io on 2020-01-24
*/
/**
* Absolutus smart contract by BioHazzardt
*/
pragma solidity ^0.5.7;
/**
* @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 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) {
uint256 c = a * b;
require(a == 0 || c / a == b, 'Invalid values');
return c;
}
/**
* @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.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
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) {
require(b <= a, 'Substraction result smaller than zero');
return a - b;
}
/**
* @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, 'Invalid values');
return c;
}
}
/**
* @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.
*
* 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 {
address public owner;
address public manager;
address public ownerWallet;
address public adminWallet;
uint adminPersent;
constructor() public {
owner = msg.sender;
manager = msg.sender;
adminWallet = 0xcFebf7C3Ec7B407DFf17aa20a2631c95c8ff508c;
ownerWallet = 0xcFebf7C3Ec7B407DFf17aa20a2631c95c8ff508c;
adminPersent = 10;
}
modifier onlyOwner() {
require(msg.sender == owner, "only for owner");
_;
}
modifier onlyOwnerOrManager() {
require((msg.sender == owner)||(msg.sender == manager), "only for owner or manager");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
function setManager(address _manager) public onlyOwnerOrManager {
manager = _manager;
}
function setAdminWallet(address _admin) public onlyOwner {
adminWallet = _admin;
}
}
contract WalletOnly {
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);
}
}
contract Absolutus is Ownable, WalletOnly {
// Events
event RegLevelEvent(address indexed _user, address indexed _referrer, uint _id, uint _time);
event BuyLevelEvent(address indexed _user, uint _level, uint _time);
event ProlongateLevelEvent(address indexed _user, uint _level, uint _time);
event GetMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint _price, bool _prevLost);
event LostMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint _price, bool _prevLost);
// New events
event PaymentForHolder(address indexed _addr, uint _index, uint _value);
event PaymentForHolderLost(address indexed _addr, uint _index, uint _value);
// Common values
mapping (uint => uint) public LEVEL_PRICE;
address canSetLevelPrice;
uint REFERRER_1_LEVEL_LIMIT = 3;
uint PERIOD_LENGTH = 365 days; // uncomment before production
uint MAX_AUTOPAY_COUNT = 5; // Automatic level buying limit per one transaction (to prevent gas limit reaching)
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
uint fund; // Fund for the automatic level pushcase
uint currentLvl; // Current user's level
address[] referral;
mapping (uint => uint) levelExpired;
mapping (uint => uint) paymentsCount;
}
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
mapping (address => uint) public allowUsers;
uint public currUserID = 0;
bool nostarted = false;
AbsDAO _dao; // DAO contract
bool daoSet = false; // if true payment processed for DAO holders
using SafeMath for uint; // <== do not forget about this
constructor() public {
// Prices in ETH: production
LEVEL_PRICE[1] = 0.5 ether;
LEVEL_PRICE[2] = 1.0 ether;
LEVEL_PRICE[3] = 2.0 ether;
LEVEL_PRICE[4] = 4.0 ether;
LEVEL_PRICE[5] = 16.0 ether;
LEVEL_PRICE[6] = 32.0 ether;
LEVEL_PRICE[7] = 64.0 ether;
LEVEL_PRICE[8] = 128.0 ether;
UserStruct memory userStruct;
currUserID++;
canSetLevelPrice = owner;
// Create root user
userStruct = UserStruct({
isExist : true,
id : currUserID,
referrerID : 0,
fund: 0,
currentLvl: 1,
referral : new address[](0)
});
users[ownerWallet] = userStruct;
userList[currUserID] = ownerWallet;
users[ownerWallet].levelExpired[1] = 77777777777;
users[ownerWallet].levelExpired[2] = 77777777777;
users[ownerWallet].levelExpired[3] = 77777777777;
users[ownerWallet].levelExpired[4] = 77777777777;
users[ownerWallet].levelExpired[5] = 77777777777;
users[ownerWallet].levelExpired[6] = 77777777777;
users[ownerWallet].levelExpired[7] = 77777777777;
users[ownerWallet].levelExpired[8] = 77777777777;
// Set inviting registration only
nostarted = true;
}
function () external payable {
require(!isContract(msg.sender), 'This contract cannot support payments from other contracts');
uint level;
// Check for payment with level price
if (msg.value == LEVEL_PRICE[1]) {
level = 1;
} else if (msg.value == LEVEL_PRICE[2]) {
level = 2;
} else if (msg.value == LEVEL_PRICE[3]) {
level = 3;
} else if (msg.value == LEVEL_PRICE[4]) {
level = 4;
} else if (msg.value == LEVEL_PRICE[5]) {
level = 5;
} else if (msg.value == LEVEL_PRICE[6]) {
level = 6;
} else if (msg.value == LEVEL_PRICE[7]) {
level = 7;
} else if (msg.value == LEVEL_PRICE[8]) {
level = 8;
} else {
// Pay to user's fund
if (!users[msg.sender].isExist || users[msg.sender].currentLvl >= 8)
revert('Incorrect Value send');
users[msg.sender].fund += msg.value;
updateCurrentLevel(msg.sender);
// if the referer is have funds for autobuy next level
if (LEVEL_PRICE[users[msg.sender].currentLvl+1] <= users[msg.sender].fund) {
buyLevelByFund(msg.sender, 0);
}
return;
}
// Buy level or register user
if (users[msg.sender].isExist) {
buyLevel(level);
} else if (level == 1) {
uint refId = 0;
address referrer = bytesToAddress(msg.data);
if (users[referrer].isExist) {
refId = users[referrer].id;
} else {
revert('Incorrect referrer');
// refId = 1;
}
regUser(refId);
} else {
revert("Please buy first level for 0.1 ETH");
}
}
// allow user in invite mode
function allowUser(address _user) public onlyOwner {
require(nostarted, 'You cant allow user in battle mode');
allowUsers[_user] = 1;
}
// disable inviting
function battleMode() public onlyOwner {
require(nostarted, 'Battle mode activated');
nostarted = false;
}
// this function sets the DAO contract address
function setDAOAddress(address payable _dao_addr) public onlyOwner {
require(!daoSet, 'DAO address already set');
_dao = AbsDAO(_dao_addr);
daoSet = true;
}
// process payment to administrator wallet
// or DAO holders
function payToAdmin(uint _amount) internal {
if (daoSet) {
// Pay for DAO
uint holderCount = _dao.getHolderCount(); // get the DAO holders count
for (uint i = 1; i <= holderCount; i++) {
uint val = _dao.getHolderPieAt(i); // get pie of holder with index == i
address payable holder = _dao.getHolder(i); // get the holder address
if (val > 0) { // check of the holder pie value
uint payValue = _amount.div(100).mul(val); // calculate amount for pay to the holder
holder.transfer(payValue);
emit PaymentForHolder(holder, i, payValue); // payment ok
} else {
emit PaymentForHolderLost(holder, i, val); // holder's pie value is zero
}
}
} else {
// pay to admin wallet
address(uint160(adminWallet)).transfer(_amount);
}
}
// user registration
function regUser(uint referrerID) public payable {
require(!isContract(msg.sender), 'This contract cannot support payments from other contracts');
if (nostarted) {
require(allowUsers[msg.sender] > 0, 'You cannot use this contract on start');
}
require(!users[msg.sender].isExist, 'User exist');
require(referrerID > 0 && referrerID <= currUserID, 'Incorrect referrer Id');
require(msg.value==LEVEL_PRICE[1], 'Incorrect Value');
// NOTE: use one more variable to prevent 'Security/No-assign-param' error (for vscode-solidity extension).
// Need to check the gas consumtion with it
uint _referrerID = referrerID;
if (users[userList[referrerID]].referral.length >= REFERRER_1_LEVEL_LIMIT) {
_referrerID = users[findFreeReferrer(userList[referrerID])].id;
}
UserStruct memory userStruct;
currUserID++;
// add user to list
userStruct = UserStruct({
isExist : true,
id : currUserID,
referrerID : _referrerID,
fund: 0,
currentLvl: 1,
referral : new address[](0)
});
users[msg.sender] = userStruct;
userList[currUserID] = msg.sender;
users[msg.sender].levelExpired[1] = now + PERIOD_LENGTH;
users[msg.sender].levelExpired[2] = 0;
users[msg.sender].levelExpired[3] = 0;
users[msg.sender].levelExpired[4] = 0;
users[msg.sender].levelExpired[5] = 0;
users[msg.sender].levelExpired[6] = 0;
users[msg.sender].levelExpired[7] = 0;
users[msg.sender].levelExpired[8] = 0;
users[userList[_referrerID]].referral.push(msg.sender);
// pay for referer
payForLevel(
1,
msg.sender,
msg.sender,
0,
false
);
emit RegLevelEvent(
msg.sender,
userList[_referrerID],
currUserID,
now
);
}
// buy level function
function buyLevel(uint _level) public payable {
require(!isContract(msg.sender), 'This contract cannot support payments from other contracts');
require(users[msg.sender].isExist, 'User not exist');
require(_level>0 && _level<=8, 'Incorrect level');
require(msg.value==LEVEL_PRICE[_level], 'Incorrect Value');
if (_level > 1) { // Replace for condition (_level == 1) on top (done)
for (uint i = _level-1; i>0; i--) {
require(users[msg.sender].levelExpired[i] >= now, 'Buy the previous level');
}
}
// if(users[msg.sender].levelExpired[_level] == 0){ <-- BUG
// if the level expired in the future, need add PERIOD_LENGTH to the level expiration time,
// or set the level expiration time to 'now + PERIOD_LENGTH' in other cases.
if (users[msg.sender].levelExpired[_level] > now) {
users[msg.sender].levelExpired[_level] += PERIOD_LENGTH;
} else {
users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
}
// Set user's current level
if (users[msg.sender].currentLvl < _level)
users[msg.sender].currentLvl = _level;
// provide payment for the user's referer
payForLevel(
_level,
msg.sender,
msg.sender,
0,
false
);
emit BuyLevelEvent(msg.sender, _level, now);
}
function setLevelPrice(uint _level, uint _price) public {
require(_level >= 0 && _level <= 8, 'Invalid level');
require(msg.sender == canSetLevelPrice, 'Invalid caller');
require(_price > 0, 'Price cannot be zero or negative');
LEVEL_PRICE[_level] = _price * 1.0 finney;
}
function setCanUpdateLevelPrice(address addr) public onlyOwner {
canSetLevelPrice = addr;
}
// for interactive correction of the limitations
function setMaxAutopayForLevelCount(uint _count) public onlyOwnerOrManager {
MAX_AUTOPAY_COUNT = _count;
}
// buyLevelByFund provides automatic payment for next level for user
function buyLevelByFund(address referer, uint _counter) internal {
require(users[referer].isExist, 'User not exists');
uint _level = users[referer].currentLvl + 1; // calculate a next level
require(users[referer].fund >= LEVEL_PRICE[_level], 'Not have funds to autobuy level');
uint remaining = users[referer].fund - LEVEL_PRICE[_level]; // Amount for pay to the referer
// extend the level's expiration time
if (users[referer].levelExpired[_level] >= now) {
users[referer].levelExpired[_level] += PERIOD_LENGTH;
} else {
users[referer].levelExpired[_level] = now + PERIOD_LENGTH;
}
users[referer].currentLvl = _level; // set current level for referer
users[referer].fund = 0; // clear the referer's fund
// process payment for next referer with increment autopay counter
payForLevel(
_level,
referer,
referer,
_counter+1,
false
);
address(uint160(referer)).transfer(remaining); // send the remaining amount to referer
emit BuyLevelEvent(referer, _level, now); // emit the buy level event for referer
}
// updateCurrentLevel calculate 'currentLvl' value for given user
function updateCurrentLevel(address _user) internal {
users[_user].currentLvl = actualLevel(_user);
}
// helper function
function actualLevel(address _user) public view returns(uint) {
require(users[_user].isExist, 'User not found');
for (uint i = 1; i <= 8; i++) {
if (users[_user].levelExpired[i] <= now) {
return i-1;
}
}
return 8;
}
// payForLevel provides payment processing for user's referer and automatic buying referer's next
// level.
function payForLevel(uint _level, address _user, address _sender, uint _autoPayCtr, bool prevLost) internal {
address referer;
address referer1;
address referer2;
address referer3;
if (_level == 1 || _level == 5) {
referer = userList[users[_user].referrerID];
} else if (_level == 2 || _level == 6) {
referer1 = userList[users[_user].referrerID];
referer = userList[users[referer1].referrerID];
} else if (_level == 3 || _level == 7) {
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer = userList[users[referer2].referrerID];
} else if (_level == 4 || _level == 8) {
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer3 = userList[users[referer2].referrerID];
referer = userList[users[referer3].referrerID];
}
if (!users[referer].isExist) {
referer = userList[1];
}
uint amountToUser;
uint amountToAdmin;
amountToAdmin = LEVEL_PRICE[_level] / 100 * adminPersent;
amountToUser = LEVEL_PRICE[_level] - amountToAdmin;
if (users[referer].id <= 4) {
payToAdmin(LEVEL_PRICE[_level]);
emit GetMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
return;
}
if (users[referer].levelExpired[_level] >= now) {
payToAdmin(amountToAdmin);
// update current referer's level
updateCurrentLevel(referer);
// check for the user has right level and automatic payment counter
// smaller than the 'MAX_AUTOPAY_COUNT' value
if (_level == users[referer].currentLvl && _autoPayCtr < MAX_AUTOPAY_COUNT && users[referer].currentLvl < 8) {
users[referer].fund += amountToUser;
emit GetMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
// if the referer is have funds for autobuy next level
if (LEVEL_PRICE[users[referer].currentLvl+1] <= users[referer].fund) {
buyLevelByFund(referer, _autoPayCtr);
}
} else {
// send the ethers to referer
address(uint160(referer)).transfer(amountToUser);
emit GetMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
}
} else {
// pay for the referer's referer
emit LostMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
payForLevel(
_level,
referer,
_sender,
_autoPayCtr,
true
);
}
}
function findFreeReferrer(address _user) public view returns(address) {
if (users[_user].referral.length < REFERRER_1_LEVEL_LIMIT) {
return _user;
}
address[] memory referrals = new address[](363);
referrals[0] = users[_user].referral[0];
referrals[1] = users[_user].referral[1];
referrals[2] = users[_user].referral[2];
address freeReferrer;
bool noFreeReferrer = true;
for (uint i = 0; i<363; i++) {
if (users[referrals[i]].referral.length == REFERRER_1_LEVEL_LIMIT) {
if (i<120) {
referrals[(i+1)*3] = users[referrals[i]].referral[0];
referrals[(i+1)*3+1] = users[referrals[i]].referral[1];
referrals[(i+1)*3+2] = users[referrals[i]].referral[2];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function viewUserReferral(address _user) public view returns(address[] memory) {
return users[_user].referral;
}
function viewUserLevelExpired(address _user, uint _level) public view returns(uint) {
return users[_user].levelExpired[_level];
}
function bytesToAddress(bytes memory bys) private pure returns (address addr ) {
assembly {
addr := mload(add(bys, 20))
}
}
}
contract AbsDAO is Ownable, WalletOnly {
// events
event TransferPie(address indexed _from, address indexed _to, uint _value);
event NewHolder(address indexed _addr, uint _index);
event HolderChanged(address indexed _from, address indexed _to, uint _index);
event PaymentReceived(address indexed _from, uint _value);
event PaymentForHolder(address indexed _addr, uint _index, uint _value);
event PaymentForHolderLost(address indexed _addr, uint _index, uint _value);
struct Holder {
bool isExist;
uint id;
uint value;
address payable addr;
}
mapping(address => Holder) public holders;
mapping(uint=>address payable) holderAddrs;
uint holderCount;
uint _initialPie = 100;
using SafeMath for uint;
constructor() public {
// creating root hoder
holderCount = 1;
holders[msg.sender] = Holder({
isExist: true,
id: 1,
value: _initialPie,
addr: msg.sender
});
holderAddrs[1] = msg.sender;
}
function () external payable { //inject DOS BY COMPLEX FALLBACK
require(!isContract(msg.sender), 'This contract cannot support payments from other contracts');
emit PaymentReceived(msg.sender, msg.value);
for (uint i = 1; i <= holderCount; i++) {
if (holders[holderAddrs[i]].value > 0) {
uint payValue = msg.value.div(100).mul(holders[holderAddrs[i]].value);
holderAddrs[i].call.gas(2301).value(payValue)("");
emit PaymentForHolder(holderAddrs[i], i, payValue);
} else {
emit PaymentForHolderLost(holderAddrs[i], i, holders[holderAddrs[i]].value);
}
}
}
function getHolderPieAt(uint i) public view returns(uint) {
return holders[holderAddrs[i]].value;
}
function getHolder(uint i) public view returns(address payable) {
return holderAddrs[i];
}
function getHolderCount() public view returns(uint) {
return holderCount;
}
function transferPie(uint _amount, address payable _to) public {
require(holders[msg.sender].isExist, 'Holder not found');
require(_amount > 0 && _amount <= holders[msg.sender].value, 'Invalid amount');
if (_amount == holders[msg.sender].value) {
uint id = holders[msg.sender].id;
delete holders[msg.sender];
holders[_to] = Holder({
isExist: true,
id: id,
value: _amount,
addr: _to
});
holderAddrs[id] = _to;
emit HolderChanged(msg.sender, _to, id);
} else {
if (holders[_to].isExist) {
holders[msg.sender].value -= _amount;
holders[_to].value += _amount;
} else if (holderCount < 20) {
holderCount += 1;
holders[msg.sender].value -= _amount;
holders[_to] = Holder({
isExist: true,
id: holderCount,
value: _amount,
addr: _to
});
holderAddrs[holderCount] = _to;
emit NewHolder(_to, holderCount);
} else {
revert('Holder limit excised');
}
}
emit TransferPie(msg.sender, _to, _amount);
}
} | payForLevel provides payment processing for user's referer and automatic buying referer's next level. | function payForLevel(uint _level, address _user, address _sender, uint _autoPayCtr, bool prevLost) internal {
address referer;
address referer1;
address referer2;
address referer3;
if (_level == 1 || _level == 5) {
referer = userList[users[_user].referrerID];
referer1 = userList[users[_user].referrerID];
referer = userList[users[referer1].referrerID];
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer = userList[users[referer2].referrerID];
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer3 = userList[users[referer2].referrerID];
referer = userList[users[referer3].referrerID];
}
} else if (_level == 2 || _level == 6) {
} else if (_level == 3 || _level == 7) {
} else if (_level == 4 || _level == 8) {
if (!users[referer].isExist) {
referer = userList[1];
}
uint amountToUser;
uint amountToAdmin;
amountToAdmin = LEVEL_PRICE[_level] / 100 * adminPersent;
amountToUser = LEVEL_PRICE[_level] - amountToAdmin;
if (users[referer].id <= 4) {
payToAdmin(LEVEL_PRICE[_level]);
emit GetMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
return;
}
if (users[referer].levelExpired[_level] >= now) {
payToAdmin(amountToAdmin);
updateCurrentLevel(referer);
if (_level == users[referer].currentLvl && _autoPayCtr < MAX_AUTOPAY_COUNT && users[referer].currentLvl < 8) {
users[referer].fund += amountToUser;
emit GetMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
if (LEVEL_PRICE[users[referer].currentLvl+1] <= users[referer].fund) {
buyLevelByFund(referer, _autoPayCtr);
}
emit GetMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
}
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
payForLevel(
_level,
referer,
_sender,
_autoPayCtr,
true
);
}
if (users[referer].levelExpired[_level] >= now) {
payToAdmin(amountToAdmin);
updateCurrentLevel(referer);
if (_level == users[referer].currentLvl && _autoPayCtr < MAX_AUTOPAY_COUNT && users[referer].currentLvl < 8) {
users[referer].fund += amountToUser;
emit GetMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
if (LEVEL_PRICE[users[referer].currentLvl+1] <= users[referer].fund) {
buyLevelByFund(referer, _autoPayCtr);
}
emit GetMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
}
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
payForLevel(
_level,
referer,
_sender,
_autoPayCtr,
true
);
}
if (users[referer].levelExpired[_level] >= now) {
payToAdmin(amountToAdmin);
updateCurrentLevel(referer);
if (_level == users[referer].currentLvl && _autoPayCtr < MAX_AUTOPAY_COUNT && users[referer].currentLvl < 8) {
users[referer].fund += amountToUser;
emit GetMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
if (LEVEL_PRICE[users[referer].currentLvl+1] <= users[referer].fund) {
buyLevelByFund(referer, _autoPayCtr);
}
emit GetMoneyForLevelEvent(
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
}
referer,
_sender,
_level,
now,
amountToUser,
prevLost
);
payForLevel(
_level,
referer,
_sender,
_autoPayCtr,
true
);
}
} else {
address(uint160(referer)).transfer(amountToUser);
} else {
emit LostMoneyForLevelEvent(
}
| 1,807,895 | [
1,
10239,
1290,
2355,
8121,
5184,
4929,
364,
729,
1807,
18068,
471,
5859,
30143,
310,
18068,
1807,
1024,
1801,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
8843,
1290,
2355,
12,
11890,
389,
2815,
16,
1758,
389,
1355,
16,
1758,
389,
15330,
16,
2254,
389,
6079,
9148,
39,
313,
16,
1426,
2807,
19024,
13,
2713,
288,
203,
3639,
1758,
18068,
31,
203,
3639,
1758,
18068,
21,
31,
203,
3639,
1758,
18068,
22,
31,
203,
3639,
1758,
18068,
23,
31,
203,
203,
3639,
309,
261,
67,
2815,
422,
404,
747,
389,
2815,
422,
1381,
13,
288,
203,
5411,
18068,
273,
729,
682,
63,
5577,
63,
67,
1355,
8009,
1734,
11110,
734,
15533,
203,
5411,
18068,
21,
273,
729,
682,
63,
5577,
63,
67,
1355,
8009,
1734,
11110,
734,
15533,
203,
5411,
18068,
273,
729,
682,
63,
5577,
63,
28596,
21,
8009,
1734,
11110,
734,
15533,
203,
5411,
18068,
21,
273,
729,
682,
63,
5577,
63,
67,
1355,
8009,
1734,
11110,
734,
15533,
203,
5411,
18068,
22,
273,
729,
682,
63,
5577,
63,
28596,
21,
8009,
1734,
11110,
734,
15533,
203,
5411,
18068,
273,
729,
682,
63,
5577,
63,
28596,
22,
8009,
1734,
11110,
734,
15533,
203,
5411,
18068,
21,
273,
729,
682,
63,
5577,
63,
67,
1355,
8009,
1734,
11110,
734,
15533,
203,
5411,
18068,
22,
273,
729,
682,
63,
5577,
63,
28596,
21,
8009,
1734,
11110,
734,
15533,
203,
5411,
18068,
23,
273,
729,
682,
63,
5577,
63,
28596,
22,
8009,
1734,
11110,
734,
15533,
203,
5411,
18068,
273,
729,
682,
63,
5577,
63,
28596,
23,
8009,
1734,
11110,
734,
15533,
203,
3639,
289,
203,
203,
3639,
289,
469,
309,
261,
67,
2815,
422,
576,
747,
389,
2815,
422,
2
] |
pragma solidity ^0.4.3;
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract BlockPaperScissors is Ownable {
using SafeMath for uint256;
ERC20Interface bCoin;
ERC20Interface pCoin;
ERC20Interface sCoin;
ERC20Interface tCoin;
address public rpsDev = msg.sender;
uint8 public lastMove = 1; // last played move; 1=rock, 2=paper, 3=scissor
address public lastPlayer = msg.sender;
uint public oneCoin = 1000000000000000000;
//FUNCTIONS setting and retrieving global variables that impact gameplay
function setBCoinContractAddress(address _address) external onlyOwner {
bCoin = ERC20Interface(_address);
}
function setPCoinContractAddress(address _address) external onlyOwner {
pCoin = ERC20Interface(_address);
}
function setSCoinContractAddress(address _address) external onlyOwner {
sCoin = ERC20Interface(_address);
}
function setTCoinContractAddress(address _address) external onlyOwner {
tCoin = ERC20Interface(_address);
}
//EVENTS
event newMove(uint8 move);
event newWinner(address winner);
// FUNCTIONS interacting with the swine structs in contract
function playBps(uint8 _choice) public returns (uint8) {
require (_choice == 1 || _choice == 2 || _choice == 3);
if (_choice == lastMove) {
tCoin.transfer(msg.sender, oneCoin);
tCoin.transfer(lastPlayer, oneCoin);// send tie token to each player
setGame(_choice, msg.sender);
return 3; // it's a tie
}
if (_choice == 1) { //choice is block
if (lastMove == 3) {
bCoin.transfer(msg.sender, oneCoin);
emit newWinner(msg.sender);
setGame(_choice, msg.sender);
return 1;// win
} else {
pCoin.transfer(lastPlayer, oneCoin);
emit newWinner(lastPlayer);
setGame(_choice, msg.sender);
return 2;//lose
}
}
if (_choice == 2) { // choice is paper
if (lastMove == 1) {
pCoin.transfer(msg.sender, oneCoin);
emit newWinner(msg.sender);
setGame(_choice, msg.sender);
return 1;// win
} else {
sCoin.transfer(lastPlayer, oneCoin);
emit newWinner(lastPlayer);
setGame(_choice, msg.sender);
return 2;//lose
}
}
if (_choice == 3) { // choice is scissors
if (lastMove == 2) {
sCoin.transfer(msg.sender, oneCoin);
emit newWinner(msg.sender);
setGame(_choice, msg.sender);
return 1;// win
} else {
bCoin.transfer(lastPlayer, oneCoin);
emit newWinner(lastPlayer);
setGame(_choice, msg.sender);
return 2;//lose
}
}
}
function setGame(uint8 _move, address _player) private {
lastMove = _move;
lastPlayer = _player;
emit newMove(_move);
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | send tie token to each player
| tCoin.transfer(lastPlayer, oneCoin); | 916,595 | [
1,
4661,
25318,
1147,
358,
1517,
7291,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
268,
27055,
18,
13866,
12,
2722,
12148,
16,
1245,
27055,
1769,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import 'OpenZeppelin/[email protected]/contracts/token/ERC20/IERC20.sol';
import 'OpenZeppelin/[email protected]/contracts/math/SafeMath.sol';
import './BasicSpell.sol';
import '../utils/HomoraMath.sol';
import '../../interfaces/ICurvePool.sol';
import '../../interfaces/ICurveRegistry.sol';
import '../../interfaces/IWLiquidityGauge.sol';
import '../../interfaces/IWERC20.sol';
contract CurveSpellV1 is BasicSpell {
using SafeMath for uint;
using HomoraMath for uint;
ICurveRegistry public immutable registry;
IWLiquidityGauge public immutable wgauge;
address public immutable crv;
mapping(address => address[]) public ulTokens; // lpToken -> underlying token array
mapping(address => address) public poolOf; // lpToken -> pool
constructor(
IBank _bank,
address _werc20,
address _weth,
address _wgauge
) public BasicSpell(_bank, _werc20, _weth) {
wgauge = IWLiquidityGauge(_wgauge);
IWLiquidityGauge(_wgauge).setApprovalForAll(address(_bank), true);
registry = IWLiquidityGauge(_wgauge).registry();
crv = address(IWLiquidityGauge(_wgauge).crv());
}
/// @dev Return pool address given LP token and update pool info if not exist.
/// @param lp LP token to find the corresponding pool.
function getPool(address lp) public returns (address) {
address pool = poolOf[lp];
if (pool == address(0)) {
require(lp != address(0), 'no lp token');
pool = registry.get_pool_from_lp_token(lp);
require(pool != address(0), 'no corresponding pool for lp token');
poolOf[lp] = pool;
uint n = registry.get_n_coins(pool);
address[8] memory tokens = registry.get_coins(pool);
ulTokens[lp] = new address[](n);
for (uint i = 0; i < n; i++) {
ulTokens[lp][i] = tokens[i];
}
}
return pool;
}
function ensureApproveN(address lp, uint n) public {
require(ulTokens[lp].length == n, 'incorrect pool length');
address pool = poolOf[lp];
address[] memory tokens = ulTokens[lp];
for (uint idx = 0; idx < n; idx++) {
ensureApprove(tokens[idx], pool);
}
}
/// @dev add liquidity for pools with 2 underlying tokens
function addLiquidity2(
address lp,
uint[2] calldata amtsUser,
uint amtLPUser,
uint[2] calldata amtsBorrow,
uint amtLPBorrow,
uint minLPMint,
uint pid,
uint gid
) external {
address pool = getPool(lp);
require(ulTokens[lp].length == 2, 'incorrect pool length');
require(wgauge.getUnderlyingToken(wgauge.encodeId(pid, gid, 0)) == lp, 'incorrect underlying');
address[] memory tokens = ulTokens[lp];
// 0. Take out collateral
uint positionId = bank.POSITION_ID();
(, , uint collId, uint collSize) = bank.getPositionInfo(positionId);
if (collSize > 0) {
(uint decodedPid, uint decodedGid, ) = wgauge.decodeId(collId);
require(decodedPid == pid && decodedGid == gid, 'incorrect coll id');
bank.takeCollateral(address(wgauge), collId, collSize);
wgauge.burn(collId, collSize);
}
// 1. Ensure approve 2 underlying tokens
ensureApproveN(lp, 2);
// 2. Get user input amounts
for (uint i = 0; i < 2; i++) doTransmit(tokens[i], amtsUser[i]);
doTransmit(lp, amtLPUser);
// 3. Borrow specified amounts
for (uint i = 0; i < 2; i++) doBorrow(tokens[i], amtsBorrow[i]);
doBorrow(lp, amtLPBorrow);
// 4. add liquidity
uint[2] memory suppliedAmts;
for (uint i = 0; i < 2; i++) {
suppliedAmts[i] = IERC20(tokens[i]).balanceOf(address(this));
}
ICurvePool(pool).add_liquidity(suppliedAmts, minLPMint);
// 5. Put collateral
uint amount = IERC20(lp).balanceOf(address(this));
ensureApprove(lp, address(wgauge));
uint id = wgauge.mint(pid, gid, amount);
bank.putCollateral(address(wgauge), id, amount);
// 6. Refund
for (uint i = 0; i < 2; i++) doRefund(tokens[i]);
// 7. Refund crv
doRefund(crv);
}
/// @dev add liquidity for pools with 3 underlying tokens
function addLiquidity3(
address lp,
uint[3] calldata amtsUser,
uint amtLPUser,
uint[3] calldata amtsBorrow,
uint amtLPBorrow,
uint minLPMint,
uint pid,
uint gid
) external {
address pool = getPool(lp);
require(ulTokens[lp].length == 3, 'incorrect pool length');
require(wgauge.getUnderlyingToken(wgauge.encodeId(pid, gid, 0)) == lp, 'incorrect underlying');
address[] memory tokens = ulTokens[lp];
// 0. take out collateral
uint positionId = bank.POSITION_ID();
(, , uint collId, uint collSize) = bank.getPositionInfo(positionId);
if (collSize > 0) {
(uint decodedPid, uint decodedGid, ) = wgauge.decodeId(collId);
require(decodedPid == pid && decodedGid == gid, 'incorrect coll id');
bank.takeCollateral(address(wgauge), collId, collSize);
wgauge.burn(collId, collSize);
}
// 1. Ensure approve 3 underlying tokens
ensureApproveN(lp, 3);
// 2. Get user input amounts
for (uint i = 0; i < 3; i++) doTransmit(tokens[i], amtsUser[i]);
doTransmit(lp, amtLPUser);
// 3. Borrow specified amounts
for (uint i = 0; i < 3; i++) doBorrow(tokens[i], amtsBorrow[i]);
doBorrow(lp, amtLPBorrow);
// 4. add liquidity
uint[3] memory suppliedAmts;
for (uint i = 0; i < 3; i++) {
suppliedAmts[i] = IERC20(tokens[i]).balanceOf(address(this));
}
ICurvePool(pool).add_liquidity(suppliedAmts, minLPMint);
// 5. put collateral
uint amount = IERC20(lp).balanceOf(address(this));
ensureApprove(lp, address(wgauge));
uint id = wgauge.mint(pid, gid, amount);
bank.putCollateral(address(wgauge), id, amount);
// 6. Refund
for (uint i = 0; i < 3; i++) doRefund(tokens[i]);
// 7. Refund crv
doRefund(crv);
}
/// @dev add liquidity for pools with 4 underlying tokens
function addLiquidity4(
address lp,
uint[4] calldata amtsUser,
uint amtLPUser,
uint[4] calldata amtsBorrow,
uint amtLPBorrow,
uint minLPMint,
uint pid,
uint gid
) external {
address pool = getPool(lp);
require(ulTokens[lp].length == 4, 'incorrect pool length');
require(wgauge.getUnderlyingToken(wgauge.encodeId(pid, gid, 0)) == lp, 'incorrect underlying');
address[] memory tokens = ulTokens[lp];
// 0. Take out collateral
uint positionId = bank.POSITION_ID();
(, , uint collId, uint collSize) = bank.getPositionInfo(positionId);
if (collSize > 0) {
(uint decodedPid, uint decodedGid, ) = wgauge.decodeId(collId);
require(decodedPid == pid && decodedGid == gid, 'incorrect coll id');
bank.takeCollateral(address(wgauge), collId, collSize);
wgauge.burn(collId, collSize);
}
// 1. Ensure approve 4 underlying tokens
ensureApproveN(lp, 4);
// 2. Get user input amounts
for (uint i = 0; i < 4; i++) doTransmit(tokens[i], amtsUser[i]);
doTransmit(lp, amtLPUser);
// 3. Borrow specified amounts
for (uint i = 0; i < 4; i++) doBorrow(tokens[i], amtsBorrow[i]);
doBorrow(lp, amtLPBorrow);
// 4. add liquidity
uint[4] memory suppliedAmts;
for (uint i = 0; i < 4; i++) {
suppliedAmts[i] = IERC20(tokens[i]).balanceOf(address(this));
}
ICurvePool(pool).add_liquidity(suppliedAmts, minLPMint);
// 5. Put collateral
uint amount = IERC20(lp).balanceOf(address(this));
ensureApprove(lp, address(wgauge));
uint id = wgauge.mint(pid, gid, amount);
bank.putCollateral(address(wgauge), id, amount);
// 6. Refund
for (uint i = 0; i < 4; i++) doRefund(tokens[i]);
// 7. Refund crv
doRefund(crv);
}
function removeLiquidity2(
address lp,
uint amtLPTake,
uint amtLPWithdraw,
uint[2] calldata amtsRepay,
uint amtLPRepay,
uint[2] calldata amtsMin
) external {
address pool = getPool(lp);
uint positionId = bank.POSITION_ID();
(, address collToken, uint collId, ) = bank.getPositionInfo(positionId);
require(IWLiquidityGauge(collToken).getUnderlyingToken(collId) == lp, 'incorrect underlying');
address[] memory tokens = ulTokens[lp];
// 0. Ensure approve
ensureApproveN(lp, 2);
// 1. Compute repay amount if MAX_INT is supplied (max debt)
uint[2] memory actualAmtsRepay;
for (uint i = 0; i < 2; i++) {
actualAmtsRepay[i] = amtsRepay[i] == uint(-1)
? bank.borrowBalanceCurrent(positionId, tokens[i])
: amtsRepay[i];
}
uint[2] memory amtsDesired;
for (uint i = 0; i < 2; i++) {
amtsDesired[i] = actualAmtsRepay[i].add(amtsMin[i]); // repay amt + slippage control
}
// 2. Take out collateral
bank.takeCollateral(address(wgauge), collId, amtLPTake);
wgauge.burn(collId, amtLPTake);
// 3. Compute amount to actually remove. Remove to repay just enough
uint amtLPToRemove;
if (amtsDesired[0] > 0 || amtsDesired[1] > 0) {
amtLPToRemove = IERC20(lp).balanceOf(address(this)).sub(amtLPWithdraw);
ICurvePool(pool).remove_liquidity_imbalance(amtsDesired, amtLPToRemove);
}
// 4. Compute leftover amount to remove. Remove balancedly.
amtLPToRemove = IERC20(lp).balanceOf(address(this)).sub(amtLPWithdraw);
uint[2] memory mins;
ICurvePool(pool).remove_liquidity(amtLPToRemove, mins);
// 5. Repay
for (uint i = 0; i < 2; i++) {
doRepay(tokens[i], actualAmtsRepay[i]);
}
doRepay(lp, amtLPRepay);
// 6. Refund
for (uint i = 0; i < 2; i++) {
doRefund(tokens[i]);
}
doRefund(lp);
// 7. Refund crv
doRefund(crv);
}
function removeLiquidity3(
address lp,
uint amtLPTake,
uint amtLPWithdraw,
uint[3] calldata amtsRepay,
uint amtLPRepay,
uint[3] calldata amtsMin
) external {
address pool = getPool(lp);
uint positionId = bank.POSITION_ID();
(, address collToken, uint collId, ) = bank.getPositionInfo(positionId);
require(IWLiquidityGauge(collToken).getUnderlyingToken(collId) == lp, 'incorrect underlying');
address[] memory tokens = ulTokens[lp];
// 0. Ensure approve
ensureApproveN(lp, 3);
// 1. Compute repay amount if MAX_INT is supplied (max debt)
uint[3] memory actualAmtsRepay;
for (uint i = 0; i < 3; i++) {
actualAmtsRepay[i] = amtsRepay[i] == uint(-1)
? bank.borrowBalanceCurrent(positionId, tokens[i])
: amtsRepay[i];
}
uint[3] memory amtsDesired;
for (uint i = 0; i < 3; i++) {
amtsDesired[i] = actualAmtsRepay[i].add(amtsMin[i]); // repay amt + slippage control
}
// 2. Take out collateral
bank.takeCollateral(address(wgauge), collId, amtLPTake);
wgauge.burn(collId, amtLPTake);
// 3. Compute amount to actually remove. Remove to repay just enough
uint amtLPToRemove;
if (amtsDesired[0] > 0 || amtsDesired[1] > 0 || amtsDesired[2] > 0) {
amtLPToRemove = IERC20(lp).balanceOf(address(this)).sub(amtLPWithdraw);
ICurvePool(pool).remove_liquidity_imbalance(amtsDesired, amtLPToRemove);
}
// 4. Compute leftover amount to remove. Remove balancedly.
amtLPToRemove = IERC20(lp).balanceOf(address(this)).sub(amtLPWithdraw);
uint[3] memory mins;
ICurvePool(pool).remove_liquidity(amtLPToRemove, mins);
// 5. Repay
for (uint i = 0; i < 3; i++) {
doRepay(tokens[i], actualAmtsRepay[i]);
}
doRepay(lp, amtLPRepay);
// 6. Refund
for (uint i = 0; i < 3; i++) {
doRefund(tokens[i]);
}
doRefund(lp);
// 7. Refund crv
doRefund(crv);
}
function removeLiquidity4(
address lp,
uint amtLPTake,
uint amtLPWithdraw,
uint[4] calldata amtsRepay,
uint amtLPRepay,
uint[4] calldata amtsMin
) external {
address pool = getPool(lp);
uint positionId = bank.POSITION_ID();
(, address collToken, uint collId, ) = bank.getPositionInfo(positionId);
require(IWLiquidityGauge(collToken).getUnderlyingToken(collId) == lp, 'incorrect underlying');
address[] memory tokens = ulTokens[lp];
// 0. Ensure approve
ensureApproveN(lp, 4);
// 1. Compute repay amount if MAX_INT is supplied (max debt)
uint[4] memory actualAmtsRepay;
for (uint i = 0; i < 4; i++) {
actualAmtsRepay[i] = amtsRepay[i] == uint(-1)
? bank.borrowBalanceCurrent(positionId, tokens[i])
: amtsRepay[i];
}
uint[4] memory amtsDesired;
for (uint i = 0; i < 4; i++) {
amtsDesired[i] = actualAmtsRepay[i].add(amtsMin[i]); // repay amt + slippage control
}
// 2. Take out collateral
bank.takeCollateral(address(wgauge), collId, amtLPTake);
wgauge.burn(collId, amtLPTake);
// 3. Compute amount to actually remove. Remove to repay just enough
uint amtLPToRemove;
if (amtsDesired[0] > 0 || amtsDesired[1] > 0 || amtsDesired[2] > 0 || amtsDesired[3] > 0) {
amtLPToRemove = IERC20(lp).balanceOf(address(this)).sub(amtLPWithdraw);
ICurvePool(pool).remove_liquidity_imbalance(amtsDesired, amtLPToRemove);
}
// 4. Compute leftover amount to remove. Remove balancedly.
amtLPToRemove = IERC20(lp).balanceOf(address(this)).sub(amtLPWithdraw);
uint[4] memory mins;
ICurvePool(pool).remove_liquidity(amtLPToRemove, mins);
// 5. Repay
for (uint i = 0; i < 4; i++) {
doRepay(tokens[i], actualAmtsRepay[i]);
}
doRepay(lp, amtLPRepay);
// 6. Refund
for (uint i = 0; i < 4; i++) {
doRefund(tokens[i]);
}
doRefund(lp);
// 7. Refund crv
doRefund(crv);
}
function harvest() external {
uint positionId = bank.POSITION_ID();
(, , uint collId, uint collSize) = bank.getPositionInfo(positionId);
(uint pid, uint gid, ) = wgauge.decodeId(collId);
address lp = wgauge.getUnderlyingToken(collId);
// 1. Take out collateral
bank.takeCollateral(address(wgauge), collId, collSize);
wgauge.burn(collId, collSize);
// 2. Put collateral
uint amount = IERC20(lp).balanceOf(address(this));
ensureApprove(lp, address(wgauge));
uint id = wgauge.mint(pid, gid, amount);
bank.putCollateral(address(wgauge), id, amount);
// 3. Refund crv
doRefund(crv);
}
}
| 0. Ensure approve 1. Compute repay amount if MAX_INT is supplied (max debt) 5. Repay 6. Refund | function removeLiquidity2(
address lp,
uint amtLPTake,
uint amtLPWithdraw,
uint[2] calldata amtsRepay,
uint amtLPRepay,
uint[2] calldata amtsMin
) external {
address pool = getPool(lp);
uint positionId = bank.POSITION_ID();
(, address collToken, uint collId, ) = bank.getPositionInfo(positionId);
require(IWLiquidityGauge(collToken).getUnderlyingToken(collId) == lp, 'incorrect underlying');
address[] memory tokens = ulTokens[lp];
ensureApproveN(lp, 2);
uint[2] memory actualAmtsRepay;
for (uint i = 0; i < 2; i++) {
actualAmtsRepay[i] = amtsRepay[i] == uint(-1)
? bank.borrowBalanceCurrent(positionId, tokens[i])
: amtsRepay[i];
}
uint[2] memory amtsDesired;
for (uint i = 0; i < 2; i++) {
}
wgauge.burn(collId, amtLPTake);
if (amtsDesired[0] > 0 || amtsDesired[1] > 0) {
amtLPToRemove = IERC20(lp).balanceOf(address(this)).sub(amtLPWithdraw);
ICurvePool(pool).remove_liquidity_imbalance(amtsDesired, amtLPToRemove);
}
uint[2] memory mins;
ICurvePool(pool).remove_liquidity(amtLPToRemove, mins);
for (uint i = 0; i < 2; i++) {
doRepay(tokens[i], actualAmtsRepay[i]);
}
doRepay(lp, amtLPRepay);
for (uint i = 0; i < 2; i++) {
doRefund(tokens[i]);
}
doRefund(lp);
}
| 12,582,183 | [
1,
20,
18,
7693,
6617,
537,
404,
18,
8155,
2071,
528,
3844,
309,
4552,
67,
3217,
353,
4580,
261,
1896,
18202,
88,
13,
1381,
18,
868,
10239,
1666,
18,
3941,
1074,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
225,
445,
1206,
48,
18988,
24237,
22,
12,
203,
565,
1758,
12423,
16,
203,
565,
2254,
25123,
48,
1856,
911,
16,
203,
565,
2254,
25123,
14461,
1190,
9446,
16,
203,
565,
2254,
63,
22,
65,
745,
892,
25123,
87,
426,
10239,
16,
203,
565,
2254,
25123,
14461,
426,
10239,
16,
203,
565,
2254,
63,
22,
65,
745,
892,
25123,
87,
2930,
203,
225,
262,
3903,
288,
203,
565,
1758,
2845,
273,
28575,
12,
9953,
1769,
203,
565,
2254,
1754,
548,
273,
11218,
18,
15258,
67,
734,
5621,
203,
565,
261,
16,
1758,
4508,
1345,
16,
2254,
4508,
548,
16,
262,
273,
11218,
18,
588,
2555,
966,
12,
3276,
548,
1769,
203,
565,
2583,
12,
45,
59,
48,
18988,
24237,
18941,
12,
12910,
1345,
2934,
588,
14655,
6291,
1345,
12,
12910,
548,
13,
422,
12423,
16,
296,
267,
6746,
6808,
8284,
203,
565,
1758,
8526,
3778,
2430,
273,
7493,
5157,
63,
9953,
15533,
203,
203,
565,
3387,
12053,
537,
50,
12,
9953,
16,
576,
1769,
203,
203,
565,
2254,
63,
22,
65,
3778,
3214,
31787,
87,
426,
10239,
31,
203,
565,
364,
261,
11890,
277,
273,
374,
31,
277,
411,
576,
31,
277,
27245,
288,
203,
1377,
3214,
31787,
87,
426,
10239,
63,
77,
65,
273,
25123,
87,
426,
10239,
63,
77,
65,
422,
2254,
19236,
21,
13,
203,
3639,
692,
11218,
18,
70,
15318,
13937,
3935,
12,
3276,
548,
16,
2430,
63,
77,
5717,
203,
3639,
294,
25123,
87,
426,
10239,
63,
77,
15533,
203,
565,
289,
203,
565,
2254,
63,
22,
65,
3778,
2
] |
./partial_match/1/0x5C5293EabBC96a62788b4CA0D393042D4e931e81/sources/src/libraries/ReallocationLib.sol | total value to deposit
| values[1] = reallocations[i][1][smartVaultStrategiesLength]; | 4,413,441 | [
1,
4963,
460,
358,
443,
1724,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
7734,
924,
63,
21,
65,
273,
2863,
12352,
63,
77,
6362,
21,
6362,
26416,
12003,
1585,
15127,
1782,
15533,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity ^0.4.4;
contract Mortal {
/* Define variable owner of the type address*/
address owner;
/* this function is executed at initialization and sets the owner of the contract */
function mortal() { owner = msg.sender; }
/* Function to recover the funds on the contract */
function kill() { if (msg.sender == owner) selfdestruct(owner); }
}
contract Greeter is Mortal {
/* define variable greeting of the type string */
bytes32 greeting;
uint32 number = 0;
function setGreeting(bytes32 _greeting) returns (bool) {
greeting = _greeting;
return true;
}
function getGreeting() constant returns (bytes32) {
return greeting;
}
} | define variable greeting of the type string */ | function setGreeting(bytes32 _greeting) returns (bool) {
greeting = _greeting;
return true;
}
| 12,849,322 | [
1,
11255,
2190,
5174,
21747,
434,
326,
618,
533,
342,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
26770,
9015,
310,
12,
3890,
1578,
389,
75,
9015,
310,
13,
1135,
261,
6430,
13,
288,
203,
3639,
5174,
21747,
273,
389,
75,
9015,
310,
31,
203,
3639,
327,
638,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity ^0.5.8;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function TOTALSUPPLY24() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF234(address account) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER72(address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE257(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING
function APPROVE45(address spender, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM346(address sender, address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER728(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL558(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function NAME136() public view returns (string memory) { //inject NONSTANDARD NAMING
return _name;
}
function SYMBOL217() public view returns (string memory) { //inject NONSTANDARD NAMING
return _symbol;
}
function DECIMALS964() public view returns (uint8) { //inject NONSTANDARD NAMING
return _decimals;
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function ADD825(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function SUB689(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function MUL868(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// 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-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function DIV452(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function MOD717(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function TOTALSUPPLY24() public view returns (uint256) { //inject NONSTANDARD NAMING
return _totalSupply;
}
function BALANCEOF234(address account) public view returns (uint256) { //inject NONSTANDARD NAMING
return _balances[account];
}
function TRANSFER72(address recipient, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER437(msg.sender, recipient, amount);
return true;
}
function ALLOWANCE257(address owner, address spender) public view returns (uint256) { //inject NONSTANDARD NAMING
return _allowances[owner][spender];
}
function APPROVE45(address spender, uint256 value) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE89(msg.sender, spender, value);
return true;
}
function TRANSFERFROM346(address sender, address recipient, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER437(sender, recipient, amount);
_APPROVE89(sender, msg.sender, _allowances[sender][msg.sender].SUB689(amount));
return true;
}
function INCREASEALLOWANCE86(address spender, uint256 addedValue) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE89(msg.sender, spender, _allowances[msg.sender][spender].ADD825(addedValue));
return true;
}
function DECREASEALLOWANCE981(address spender, uint256 subtractedValue) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE89(msg.sender, spender, _allowances[msg.sender][spender].SUB689(subtractedValue));
return true;
}
function _TRANSFER437(address sender, address recipient, uint256 amount) internal { //inject NONSTANDARD NAMING
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].SUB689(amount);
_balances[recipient] = _balances[recipient].ADD825(amount);
emit TRANSFER728(sender, recipient, amount);
}
function _MINT126(address account, uint256 amount) internal { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.ADD825(amount);
_balances[account] = _balances[account].ADD825(amount);
emit TRANSFER728(address(0), account, amount);
}
function _BURN761(address account, uint256 value) internal { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.SUB689(value);
_balances[account] = _balances[account].SUB689(value);
emit TRANSFER728(account, address(0), value);
}
function _APPROVE89(address owner, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit APPROVAL558(owner, spender, value);
}
function _BURNFROM912(address account, uint256 amount) internal { //inject NONSTANDARD NAMING
_BURN761(account, amount);
_APPROVE89(account, msg.sender, _allowances[account][msg.sender].SUB689(amount));
}
}
// File: openzeppelin-solidity/contracts/access/Roles.sol
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function ADD825(Role storage role, address account) internal { //inject NONSTANDARD NAMING
require(!HAS200(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function REMOVE879(Role storage role, address account) internal { //inject NONSTANDARD NAMING
require(HAS200(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function HAS200(Role storage role, address account) internal view returns (bool) { //inject NONSTANDARD NAMING
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol
contract MinterRole {
using Roles for Roles.Role;
event MINTERADDED281(address indexed account); //inject NONSTANDARD NAMING
event MINTERREMOVED788(address indexed account); //inject NONSTANDARD NAMING
Roles.Role private _minters;
constructor () internal {
_ADDMINTER695(msg.sender);
}
modifier ONLYMINTER448() { //inject NONSTANDARD NAMING
require(ISMINTER103(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function ISMINTER103(address account) public view returns (bool) { //inject NONSTANDARD NAMING
return _minters.HAS200(account);
}
function ADDMINTER340(address account) public ONLYMINTER448 { //inject NONSTANDARD NAMING
_ADDMINTER695(account);
}
function RENOUNCEMINTER82() public { //inject NONSTANDARD NAMING
_REMOVEMINTER969(msg.sender);
}
function _ADDMINTER695(address account) internal { //inject NONSTANDARD NAMING
_minters.ADD825(account);
emit MINTERADDED281(account);
}
function _REMOVEMINTER969(address account) internal { //inject NONSTANDARD NAMING
_minters.REMOVE879(account);
emit MINTERREMOVED788(account);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Mintable.sol
contract ERC20Mintable is ERC20, MinterRole {
function MINT699(address account, uint256 amount) public ONLYMINTER448 returns (bool) { //inject NONSTANDARD NAMING
_MINT126(account, amount);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Capped.sol
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
function CAP280() public view returns (uint256) { //inject NONSTANDARD NAMING
return _cap;
}
function _MINT126(address account, uint256 value) internal { //inject NONSTANDARD NAMING
require(TOTALSUPPLY24().ADD825(value) <= _cap, "ERC20Capped: cap exceeded");
super._MINT126(account, value);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol
contract ERC20Burnable is ERC20 {
function BURN558(uint256 amount) public { //inject NONSTANDARD NAMING
_BURN761(msg.sender, amount);
}
function BURNFROM709(address account, uint256 amount) public { //inject NONSTANDARD NAMING
_BURNFROM912(account, amount);
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OWNERSHIPTRANSFERRED785(address indexed previousOwner, address indexed newOwner); //inject NONSTANDARD NAMING
constructor () internal {
_owner = msg.sender;
emit OWNERSHIPTRANSFERRED785(address(0), _owner);
}
function OWNER790() public view returns (address) { //inject NONSTANDARD NAMING
return _owner;
}
modifier ONLYOWNER785() { //inject NONSTANDARD NAMING
require(ISOWNER48(), "Ownable: caller is not the owner");
_;
}
function ISOWNER48() public view returns (bool) { //inject NONSTANDARD NAMING
return msg.sender == _owner;
}
function RENOUNCEOWNERSHIP92() public ONLYOWNER785 { //inject NONSTANDARD NAMING
emit OWNERSHIPTRANSFERRED785(_owner, address(0));
_owner = address(0);
}
function TRANSFEROWNERSHIP413(address newOwner) public ONLYOWNER785 { //inject NONSTANDARD NAMING
_TRANSFEROWNERSHIP978(newOwner);
}
function _TRANSFEROWNERSHIP978(address newOwner) internal { //inject NONSTANDARD NAMING
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OWNERSHIPTRANSFERRED785(_owner, newOwner);
_owner = newOwner;
}
}
// File: eth-token-recover/contracts/TokenRecover.sol
contract TokenRecover is Ownable {
function RECOVERERC20723(address tokenAddress, uint256 tokenAmount) public ONLYOWNER785 { //inject NONSTANDARD NAMING
IERC20(tokenAddress).TRANSFER72(OWNER790(), tokenAmount);
}
}
// File: ico-maker/contracts/access/roles/OperatorRole.sol
contract OperatorRole {
using Roles for Roles.Role;
event OPERATORADDED875(address indexed account); //inject NONSTANDARD NAMING
event OPERATORREMOVED255(address indexed account); //inject NONSTANDARD NAMING
Roles.Role private _operators;
constructor() internal {
_ADDOPERATOR101(msg.sender);
}
modifier ONLYOPERATOR594() { //inject NONSTANDARD NAMING
require(ISOPERATOR640(msg.sender));
_;
}
function ISOPERATOR640(address account) public view returns (bool) { //inject NONSTANDARD NAMING
return _operators.HAS200(account);
}
function ADDOPERATOR763(address account) public ONLYOPERATOR594 { //inject NONSTANDARD NAMING
_ADDOPERATOR101(account);
}
function RENOUNCEOPERATOR674() public { //inject NONSTANDARD NAMING
_REMOVEOPERATOR451(msg.sender);
}
function _ADDOPERATOR101(address account) internal { //inject NONSTANDARD NAMING
_operators.ADD825(account);
emit OPERATORADDED875(account);
}
function _REMOVEOPERATOR451(address account) internal { //inject NONSTANDARD NAMING
_operators.REMOVE879(account);
emit OPERATORREMOVED255(account);
}
}
// File: ico-maker/contracts/token/ERC20/BaseERC20Token.sol
contract BaseERC20Token is ERC20Detailed, ERC20Capped, ERC20Burnable, OperatorRole, TokenRecover {
event MINTFINISHED767(); //inject NONSTANDARD NAMING
event TRANSFERENABLED385(); //inject NONSTANDARD NAMING
// indicates if minting is finished
bool private _mintingFinished = false;
// indicates if transfer is enabled
bool private _transferEnabled = false;
modifier CANMINT798() { //inject NONSTANDARD NAMING
require(!_mintingFinished);
_;
}
modifier CANTRANSFER140(address from) { //inject NONSTANDARD NAMING
require(_transferEnabled || ISOPERATOR640(from));
_;
}
constructor(
string memory name,
string memory symbol,
uint8 decimals,
uint256 cap,
uint256 initialSupply
)
public
ERC20Detailed(name, symbol, decimals)
ERC20Capped(cap)
{
if (initialSupply > 0) {
_MINT126(OWNER790(), initialSupply);
}
}
function MINTINGFINISHED780() public view returns (bool) { //inject NONSTANDARD NAMING
return _mintingFinished;
}
function TRANSFERENABLED7() public view returns (bool) { //inject NONSTANDARD NAMING
return _transferEnabled;
}
function MINT699(address to, uint256 value) public CANMINT798 returns (bool) { //inject NONSTANDARD NAMING
return super.MINT699(to, value);
}
function TRANSFER72(address to, uint256 value) public CANTRANSFER140(msg.sender) returns (bool) { //inject NONSTANDARD NAMING
return super.TRANSFER72(to, value);
}
function TRANSFERFROM346(address from, address to, uint256 value) public CANTRANSFER140(from) returns (bool) { //inject NONSTANDARD NAMING
return super.TRANSFERFROM346(from, to, value);
}
function FINISHMINTING211() public ONLYOWNER785 CANMINT798 { //inject NONSTANDARD NAMING
_mintingFinished = true;
emit MINTFINISHED767();
}
function ENABLETRANSFER141() public ONLYOWNER785 { //inject NONSTANDARD NAMING
_transferEnabled = true;
emit TRANSFERENABLED385();
}
function REMOVEOPERATOR532(address account) public ONLYOWNER785 { //inject NONSTANDARD NAMING
_REMOVEOPERATOR451(account);
}
function REMOVEMINTER389(address account) public ONLYOWNER785 { //inject NONSTANDARD NAMING
_REMOVEMINTER969(account);
}
}
// File: contracts/ERC20Token.sol
contract ERC20Token is BaseERC20Token {
string public builtOn = "https://vittominacori.github.io/erc20-generator";
constructor(
string memory name,
string memory symbol,
uint8 decimals,
uint256 cap,
uint256 initialSupply
)
public
BaseERC20Token(name, symbol, decimals, cap, initialSupply)
{} // solhint-disable-line no-empty-blocks
} | inject NONSTANDARD NAMING
| function REMOVE879(Role storage role, address account) internal { | 2,480,299 | [
1,
22170,
18708,
882,
18264,
423,
2192,
1360,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
26056,
28,
7235,
12,
2996,
2502,
2478,
16,
1758,
2236,
13,
2713,
288,
202,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
/**
* @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) {
return msg.data;
}
}
/**
* @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) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @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");
(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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
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
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint256 count;
for (uint256 i; i < _owners.length; ++i) {
if (owner == _owners[i]) ++count;
}
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` 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 tokenId
) internal virtual {}
}
contract VRFRequestIDBase {
/**
* @notice returns the seed which is actually input to the VRF coordinator
*
* @dev To prevent repetition of VRF output due to repetition of the
* @dev user-supplied seed, that seed is combined in a hash with the
* @dev user-specific nonce, and the address of the consuming contract. The
* @dev risk of repetition is mostly mitigated by inclusion of a blockhash in
* @dev the final seed, but the nonce does protect against repetition in
* @dev requests which are included in a single block.
*
* @param _userSeed VRF seed input provided by user
* @param _requester Address of the requesting contract
* @param _nonce User-specific nonce at the time of the request
*/
function makeVRFInputSeed(
bytes32 _keyHash,
uint256 _userSeed,
address _requester,
uint256 _nonce
) internal pure returns (uint256) {
return uint256(keccak256(abi.encode(_keyHash, _userSeed, _requester, _nonce)));
}
/**
* @notice Returns the id for this request
* @param _keyHash The serviceAgreement ID to be used for this request
* @param _vRFInputSeed The seed to be passed directly to the VRF
* @return The id for this request
*
* @dev Note that _vRFInputSeed is not the seed passed by the consuming
* @dev contract, but the one generated by makeVRFInputSeed
*/
function makeRequestId(bytes32 _keyHash, uint256 _vRFInputSeed) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(_keyHash, _vRFInputSeed));
}
}
interface LinkTokenInterface {
function allowance(address owner, address spender) external view returns (uint256 remaining);
function approve(address spender, uint256 value) external returns (bool success);
function balanceOf(address owner) external view returns (uint256 balance);
function decimals() external view returns (uint8 decimalPlaces);
function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);
function increaseApproval(address spender, uint256 subtractedValue) external;
function name() external view returns (string memory tokenName);
function symbol() external view returns (string memory tokenSymbol);
function totalSupply() external view returns (uint256 totalTokensIssued);
function transfer(address to, uint256 value) external returns (bool success);
function transferAndCall(
address to,
uint256 value,
bytes calldata data
) external returns (bool success);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool success);
}
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account but rips out the core of the gas-wasting processing that comes from OpenZeppelin.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _owners.length;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < _owners.length, "ERC721Enumerable: global index out of bounds");
return index;
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256 tokenId) {
require(index < balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
uint256 count;
for (uint256 i; i < _owners.length; i++) {
if (owner == _owners[i]) {
if (count == index) return i;
else count++;
}
}
revert("ERC721Enumerable: owner index out of bounds");
}
}
interface IIllogics {
function isAdmin(address addr) external view returns (bool);
function mintGoop(address _addr, uint256 _goop) external;
function burnGoop(address _addr, uint256 _goop) external;
function spendGoop(uint256 _item, uint256 _count) external;
function mintGoopBatch(address[] calldata _addr, uint256 _goop) external;
function burnGoopBatch(address[] calldata _addr, uint256 _goop) external;
}
/** ****************************************************************************
* @notice Interface for contracts using VRF randomness
* *****************************************************************************
* @dev PURPOSE
*
* @dev Reggie the Random Oracle (not his real job) wants to provide randomness
* @dev to Vera the verifier in such a way that Vera can be sure he's not
* @dev making his output up to suit himself. Reggie provides Vera a public key
* @dev to which he knows the secret key. Each time Vera provides a seed to
* @dev Reggie, he gives back a value which is computed completely
* @dev deterministically from the seed and the secret key.
*
* @dev Reggie provides a proof by which Vera can verify that the output was
* @dev correctly computed once Reggie tells it to her, but without that proof,
* @dev the output is indistinguishable to her from a uniform random sample
* @dev from the output space.
*
* @dev The purpose of this contract is to make it easy for unrelated contracts
* @dev to talk to Vera the verifier about the work Reggie is doing, to provide
* @dev simple access to a verifiable source of randomness.
* *****************************************************************************
* @dev USAGE
*
* @dev Calling contracts must inherit from VRFConsumerBase, and can
* @dev initialize VRFConsumerBase's attributes in their constructor as
* @dev shown:
*
* @dev contract VRFConsumer {
* @dev constuctor(<other arguments>, address _vrfCoordinator, address _link)
* @dev VRFConsumerBase(_vrfCoordinator, _link) public {
* @dev <initialization with other arguments goes here>
* @dev }
* @dev }
*
* @dev The oracle will have given you an ID for the VRF keypair they have
* @dev committed to (let's call it keyHash), and have told you the minimum LINK
* @dev price for VRF service. Make sure your contract has sufficient LINK, and
* @dev call requestRandomness(keyHash, fee, seed), where seed is the input you
* @dev want to generate randomness from.
*
* @dev Once the VRFCoordinator has received and validated the oracle's response
* @dev to your request, it will call your contract's fulfillRandomness method.
*
* @dev The randomness argument to fulfillRandomness is the actual random value
* @dev generated from your seed.
*
* @dev The requestId argument is generated from the keyHash and the seed by
* @dev makeRequestId(keyHash, seed). If your contract could have concurrent
* @dev requests open, you can use the requestId to track which seed is
* @dev associated with which randomness. See VRFRequestIDBase.sol for more
* @dev details. (See "SECURITY CONSIDERATIONS" for principles to keep in mind,
* @dev if your contract could have multiple requests in flight simultaneously.)
*
* @dev Colliding `requestId`s are cryptographically impossible as long as seeds
* @dev differ. (Which is critical to making unpredictable randomness! See the
* @dev next section.)
*
* *****************************************************************************
* @dev SECURITY CONSIDERATIONS
*
* @dev A method with the ability to call your fulfillRandomness method directly
* @dev could spoof a VRF response with any random value, so it's critical that
* @dev it cannot be directly called by anything other than this base contract
* @dev (specifically, by the VRFConsumerBase.rawFulfillRandomness method).
*
* @dev For your users to trust that your contract's random behavior is free
* @dev from malicious interference, it's best if you can write it so that all
* @dev behaviors implied by a VRF response are executed *during* your
* @dev fulfillRandomness method. If your contract must store the response (or
* @dev anything derived from it) and use it later, you must ensure that any
* @dev user-significant behavior which depends on that stored value cannot be
* @dev manipulated by a subsequent VRF request.
*
* @dev Similarly, both miners and the VRF oracle itself have some influence
* @dev over the order in which VRF responses appear on the blockchain, so if
* @dev your contract could have multiple VRF requests in flight simultaneously,
* @dev you must ensure that the order in which the VRF responses arrive cannot
* @dev be used to manipulate your contract's user-significant behavior.
*
* @dev Since the ultimate input to the VRF is mixed with the block hash of the
* @dev block in which the request is made, user-provided seeds have no impact
* @dev on its economic security properties. They are only included for API
* @dev compatability with previous versions of this contract.
*
* @dev Since the block hash of the block which contains the requestRandomness
* @dev call is mixed into the input to the VRF *last*, a sufficiently powerful
* @dev miner could, in principle, fork the blockchain to evict the block
* @dev containing the request, forcing the request to be included in a
* @dev different block with a different hash, and therefore a different input
* @dev to the VRF. However, such an attack would incur a substantial economic
* @dev cost. This cost scales with the number of blocks the VRF oracle waits
* @dev until it calls responds to a request.
*/
abstract contract VRFConsumerBase is VRFRequestIDBase {
/**
* @notice fulfillRandomness handles the VRF response. Your contract must
* @notice implement it. See "SECURITY CONSIDERATIONS" above for ////important
* @notice principles to keep in mind when implementing your fulfillRandomness
* @notice method.
*
* @dev VRFConsumerBase expects its subcontracts to have a method with this
* @dev signature, and will call it once it has verified the proof
* @dev associated with the randomness. (It is triggered via a call to
* @dev rawFulfillRandomness, below.)
*
* @param requestId The Id initially returned by requestRandomness
* @param randomness the VRF output
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal virtual;
/**
* @dev In order to keep backwards compatibility we have kept the user
* seed field around. We remove the use of it because given that the blockhash
* enters later, it overrides whatever randomness the used seed provides.
* Given that it adds no security, and can easily lead to misunderstandings,
* we have removed it from usage and can now provide a simpler API.
*/
uint256 private constant USER_SEED_PLACEHOLDER = 0;
/**
* @notice requestRandomness initiates a request for VRF output given _seed
*
* @dev The fulfillRandomness method receives the output, once it's provided
* @dev by the Oracle, and verified by the vrfCoordinator.
*
* @dev The _keyHash must already be registered with the VRFCoordinator, and
* @dev the _fee must exceed the fee specified during registration of the
* @dev _keyHash.
*
* @dev The _seed parameter is vestigial, and is kept only for API
* @dev compatibility with older versions. It can't *hurt* to mix in some of
* @dev your own randomness, here, but it's not necessary because the VRF
* @dev oracle will mix the hash of the block containing your request into the
* @dev VRF seed it ultimately uses.
*
* @param _keyHash ID of public key against which randomness is generated
* @param _fee The amount of LINK to send with the request
*
* @return requestId unique ID for this request
*
* @dev The returned requestId can be used to distinguish responses to
* @dev concurrent requests. It is passed as the first argument to
* @dev fulfillRandomness.
*/
function requestRandomness(bytes32 _keyHash, uint256 _fee) internal returns (bytes32 requestId) {
LINK.transferAndCall(vrfCoordinator, _fee, abi.encode(_keyHash, USER_SEED_PLACEHOLDER));
// This is the seed passed to VRFCoordinator. The oracle will mix this with
// the hash of the block containing this request to obtain the seed/input
// which is finally passed to the VRF cryptographic machinery.
uint256 vRFSeed = makeVRFInputSeed(_keyHash, USER_SEED_PLACEHOLDER, address(this), nonces[_keyHash]);
// nonces[_keyHash] must stay in sync with
// VRFCoordinator.nonces[_keyHash][this], which was incremented by the above
// successful LINK.transferAndCall (in VRFCoordinator.randomnessRequest).
// This provides protection against the user repeating their input seed,
// which would result in a predictable/duplicate output, if multiple such
// requests appeared in the same block.
nonces[_keyHash] = nonces[_keyHash] + 1;
return makeRequestId(_keyHash, vRFSeed);
}
LinkTokenInterface internal immutable LINK;
address private immutable vrfCoordinator;
// Nonces for each VRF key from which randomness has been requested.
//
// Must stay in sync with VRFCoordinator[_keyHash][this]
mapping(bytes32 => uint256) /* keyHash */ /* nonce */
private nonces;
/**
* @param _vrfCoordinator address of VRFCoordinator contract
* @param _link address of LINK token contract
*
* @dev https://docs.chain.link/docs/link-token-contracts
*/
constructor(address _vrfCoordinator, address _link) {
vrfCoordinator = _vrfCoordinator;
LINK = LinkTokenInterface(_link);
}
// rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
// proof. rawFulfillRandomness then calls fulfillRandomness, after validating
// the origin of the call
function rawFulfillRandomness(bytes32 requestId, uint256 randomness) external {
require(msg.sender == vrfCoordinator, "Only VRFCoordinator can fulfill");
fulfillRandomness(requestId, randomness);
}
}
/**
* @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 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.
*/
abstract 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() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(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");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
/**
* @dev These functions deal with verification of Merkle Trees proofs.
*
* The proofs can be generated using the JavaScript library
* https://github.com/miguelmota/merkletreejs[merkletreejs].
* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
*
* See `test/utils/cryptography/MerkleProof.test.js` for some examples.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
// Hash(current computed hash + current element of the proof)
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
// Hash(current element of the proof + current computed hash)
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
return computedHash;
}
}
interface ILab {
function getIllogical(uint256 _tokenId) external view returns (uint256);
}
contract illogics is IIllogics, ERC721Enumerable, Ownable, VRFConsumerBase {
/**************************
*
* DATA STRUCTURES & ENUM
*
**************************/
// Data structure that defines the elements of stakedToken
struct StakedToken {
address ownerOfNFT;
uint256 timestamp;
uint256 lastRerollPeriod;
}
// Data structure that defines the elements of a saleId
struct Sale {
string description;
bool saleStatus;
uint256 price;
uint256 supply;
uint256 maxPurchase;
}
/**************************
*
* State Variables
*
**************************/
// ***** constants and assignments *****
uint256 public maxMint = 2; // ill-list max per minter address
uint256 public constant REROLL_COST = 50; // Goop required to reroll a token
uint256 public constant GOOP_INTERVAL = 12 hours; // The interval upon which Goop is calcualated
uint256 public goopPerInterval = 5; // Goop awarded per interval
address public teamWallet = 0xB3D1b19202423EcD55ACF1E635ea1Bded11a5c9f; // address of the team wallet
// ***** ill-list minting *****
bool public mintingState; // enable/disable minting
bytes32 public merkleRoot; // ill-list Merkle Root
// ***** Chainlink VRF & tokenID *****
IERC20 public link; // address of Chainlink token contract
uint256 public VRF_fee; // Chainlink VRF fee
uint256 public periodCounter; // current VRF period
bytes32 public VRF_keyHash; // Chainlink VRF random number keyhash
string public baseURI; // URI to illogics metadata
// ***** Goop ecosystem & Sales *****
uint256 public totalGoopSupply; // total Goop in circulation
uint256 public totalGoopSpent; // total Goop spent in the ecosystem
uint256 public saleId; // last saleID applied to a saleItem
// ***** feature state management *****
bool public spendState; // Goop spending state
bool public rerollState; // reroll function state
bool public stakingState; // staking state
bool public transferState; // Goop P2P transfer state
bool public claimStatus; // Goop claim status
bool public verifyVRF; // can only be set once, used to validate the Chainlink config prior to mint
// ***** OpenSea *****
address public proxyRegistryAddress; // proxyRegistry address
// ***** TheLab *****
address public labAddress; // the address of TheLab ;)
/**************************
*
* Mappings
*
**************************/
mapping(uint256 => Sale) public saleItems; // mapping of saleId to the Sale data scructure
mapping(uint256 => StakedToken) public stakedToken; // mapping of tokenId to the StakedToken data structure
mapping(address => uint256) public goop; // mapping of address to a Goop balance
mapping(address => uint256[]) public staker; // mapping of address to owned tokens staked
mapping(uint256 => uint256) public collectionDNA; // mapping of VRF period to seed DNA for said period
mapping(uint256 => uint256[]) public rollTracker; // mapping reroll period (periodCounter) entered to tokenIds
mapping(address => bool) private admins; // mapping of address to an administrative status
mapping(address => bool) public projectProxy; // mapping of address to projectProxy status
mapping(address => bool) public addressToMinted; // mapping of address to minted status
mapping(address => mapping(uint256 => uint256)) public addressPurchases; // mapping of an address to an saleItemId to number of units purchased
/**********************************************************
*
* Events
*
**********************************************************/
event RequestedRandomNumber(bytes32 indexed requestId); // emitted when the ChainLink VRF is requested
event RecievedRandomNumber(bytes32 indexed requestId, uint256 periodCounter, uint256 randomNumber); // emitted when a random number is recieved by the Chainlink VRF callback()
event spentGoop(address indexed purchaser, uint256 indexed item, uint256 indexed count); //emitted when an item is purchased with Goop
/**********************************************************
*
* Constructor
*
**********************************************************/
/**
* @dev Initializes the contract by:
* - setting a `name` and a `symbol` in the ERC721 constructor
* - setting the Chainlnk VRFConsumerBase constructor
* - setting collection dependant assignments
*/
constructor(
bytes32 _VRF_keyHash,
uint256 _VRF_Fee,
address _vrfCoordinator,
address _linkToken
) ERC721("illogics", "ill") VRFConsumerBase(_vrfCoordinator, _linkToken) {
VRF_keyHash = _VRF_keyHash;
VRF_fee = _VRF_Fee;
link = IERC20(address(_linkToken));
admins[_msgSender()] = true;
proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
}
/**********************************************************
*
* Modifiers
*
**********************************************************/
/**
* @dev Ensures only contract admins can execute privileged functions
*/
modifier onlyAdmin() {
require(isAdmin(_msgSender()), "admins only");
_;
}
/**********************************************************
*
* Contract Management
*
**********************************************************/
/**
* @dev Check is an address is an admin
*/
function isAdmin(address _addr) public view override returns (bool) {
return owner() == _addr || admins[_addr];
}
/**
* @dev Grant administrative control to an address
*/
function addAdmin(address _addr) external onlyAdmin {
admins[_addr] = true;
}
/**
* @dev Revoke administrative control for an address
*/
function removeAdmin(address _addr) external onlyAdmin {
admins[_addr] = false;
}
/**********************************************************
*
* Admin and Contract setters
*
**********************************************************/
/**
* @dev running this after the constructor adds the deployed address
* of this contract to the admins
*/
function init() external onlyAdmin {
admins[address(this)] = true;
}
/**
* @dev enables//disables minting state
*/
function setMintingState(bool _state) external onlyAdmin {
mintingState = _state;
}
/**
* @dev enable/disable staking, this does not impact unstaking
*/
function setStakingState(bool _state) external onlyAdmin {
stakingState = _state;
}
/**
* @dev enable/disable reroll, this must be in a disabled state
* prior to calling the final VRF
*/
function setRerollState(bool _state) external onlyAdmin {
rerollState = _state;
}
/**
* @dev enable/disable P2P transfer of Goop
*/
function setTransferState(bool _state) external onlyAdmin {
transferState = _state;
}
/**
* @dev enable/disable the ability to spend Goop
*/
function setSpendState(bool _state) external onlyAdmin {
spendState = _state;
}
/**
* @dev set TheLab address (likely some future Alpha here)
*/
function setLabAddress(address _labAddress) external onlyAdmin {
labAddress = _labAddress;
}
/**
* @dev set the baseURI.
*/
function setBaseURI(string memory _baseURI) public onlyAdmin {
baseURI = _baseURI;
}
/**
* @dev Set the maxMint
*/
function setMaxMint(uint256 _maxMint) external onlyAdmin {
maxMint = _maxMint;
}
/**
* @dev set the amount of Goop earned per interval
*/
function setGoopPerInterval(uint256 _goopPerInterval) external onlyAdmin {
goopPerInterval = _goopPerInterval;
}
/**
* @dev enable/disable Goop claiming
*/
function setClaim(bool _claimStatus) external onlyAdmin {
claimStatus = _claimStatus;
}
/**********************************************************
*
* The illest ill-list
*
**********************************************************/
/**
* @dev set the merkleTree root
*/
function setMerkleRoot(bytes32 _merkleRoot) public onlyAdmin {
merkleRoot = _merkleRoot;
}
/**
* @dev calculates the leaf hash
*/
function leaf(string memory payload) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(payload));
}
/**
* @dev verifies the inclusion of the leaf hash in the merkleTree
*/
function verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool) {
return MerkleProof.verify(proof, merkleRoot, leaf);
}
/**********************************************************
*
* TheLab
*
**********************************************************/
/**
* @notice expect big things from this...
*/
function multiHelix(uint256 _tokenId) public view returns (uint256) {
require(labAddress != address(0x0), "The Lab is being setup.");
return ILab(labAddress).getIllogical(_tokenId);
}
/**********************************************************
*
* Token management
*
**********************************************************/
/**
* @dev ill-list leverages merkleTree for the mint, there is no public sale.
*
* The first token in the collection is 0 and the last token is 8887, which
* equates to a collection size of 8888. Gas optimization uses an index based
* model that returns an array size of 8888. As another gas optimization, we
* refrained from <= or >= and as a result we must +1, hence the < 8889.
*/
function illListMint(bytes32[] calldata proof) public payable {
string memory payload = string(abi.encodePacked(_msgSender()));
uint256 totalSupply = _owners.length;
require(mintingState, "Ill-list not active");
require(verify(leaf(payload), proof), "Invalid Merkle Tree proof supplied");
require(addressToMinted[_msgSender()] == false, "can not mint twice");
require(totalSupply + maxMint < 8889, "project fully minted");
addressToMinted[_msgSender()] = true;
for (uint256 i; i < maxMint; i++) {
_mint(_msgSender(), totalSupply + i);
}
}
/**
* @dev mints 'tId' to 'address'
*/
function _mint(address to, uint256 tId) internal virtual override {
_owners.push(to);
emit Transfer(address(0), to, tId);
}
/**********************************************************
*
* TOKEN
*
**********************************************************/
/**
* @dev Returns the Uniform Resource Identifier (URI) for the `tokenId` token.
*/
function tokenURI(uint256 _tId) public view override returns (string memory) {
require(_exists(_tId), "Token does not exist.");
return string(abi.encodePacked(baseURI, Strings.toString(_tId)));
}
/**
* @dev transfer an array of tokens from '_from' address to '_to' address
*/
function batchTransferFrom(
address _from,
address _to,
uint256[] memory _tIds
) public {
for (uint256 i = 0; i < _tIds.length; i++) {
transferFrom(_from, _to, _tIds[i]);
}
}
/**
* @dev safe transfer an array of tokens from '_from' address to '_to' address
*/
function batchSafeTransferFrom(
address _from,
address _to,
uint256[] memory _tIds,
bytes memory data_
) public {
for (uint256 i = 0; i < _tIds.length; i++) {
safeTransferFrom(_from, _to, _tIds[i], data_);
}
}
/**
* @dev returns a confirmation that 'tIds' are owned by 'account'
*/
function isOwnerOf(address account, uint256[] calldata _tIds) external view returns (bool) {
for (uint256 i; i < _tIds.length; ++i) {
if (_owners[_tIds[i]] != account) return false;
}
return true;
}
/**
* @dev Retunrs the tokenIds of 'owner'
*/
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) return new uint256[](0);
uint256[] memory tokensId = new uint256[](tokenCount);
for (uint256 i; i < tokenCount; i++) {
tokensId[i] = tokenOfOwnerByIndex(_owner, i);
}
return tokensId;
}
/**********************************************************
*
* GENEROSITY + ETH FUNDING
*
**********************************************************/
/**
* @dev Just in case someone sends ETH to the contract
*/
function withdraw() public {
(bool success, ) = teamWallet.call{value: address(this).balance}("");
require(success, "Failed to send.");
}
receive() external payable {}
/**********************************************************
*
* CHAINLINK VRF & TOKEN DNA
*
**********************************************************/
/**
* @dev Requests a random number from the Chainlink VRF
*/
function requestRandomNumber() external onlyAdmin returns (bytes32 requestId) {
require(LINK.balanceOf(address(this)) >= VRF_fee, "Not enough LINK");
requestId = requestRandomness(VRF_keyHash, VRF_fee);
emit RequestedRandomNumber(requestId);
}
/**
* @dev Receives the random number from the Chainlink VRF callback
*/
function fulfillRandomness(bytes32 _requestId, uint256 _randomNumber) internal override {
periodCounter++;
collectionDNA[periodCounter] = _randomNumber;
emit RecievedRandomNumber(_requestId, periodCounter, _randomNumber);
}
/**
* @dev this allows you to test the VRF call to ensure it works as expected prior to mint
* It resets the collectionDNA and period counter to defaults prior to minting.
*/
function setVerifyVRF() external onlyAdmin {
require(!verifyVRF, "this is a one way function it can not be called twice");
collectionDNA[1] = 0;
periodCounter = 0;
verifyVRF = true;
}
/**
* @notice A reroll is an opportunity to change your tokenDNA and only available when reroll is enabled.
* A token that is rerolled gets brand new tokenDNA that is generated in the next reroll period
* with the result of the Chainlink VRF requestRandomNumber(). Its impossible to know the result
* of your reroll in advance of the Chainlink call and as a result you may end up with a rarer
* or less rare tokenDNA.
*/
function reroll(uint256[] calldata _tokenIds) external {
uint256 amount = REROLL_COST * _tokenIds.length;
require(rerollState, "reroll not enabled");
require(goop[_msgSender()] >= amount, "not enough goop for reroll");
for (uint256 i = 0; i < _tokenIds.length; i++) {
require(stakedToken[_tokenIds[i]].ownerOfNFT == _msgSender(), "you dont own this token or its not staked");
rollTracker[periodCounter + 1].push(_tokenIds[i]);
stakedToken[_tokenIds[i]].lastRerollPeriod = periodCounter;
}
_burnGoop(_msgSender(), amount);
}
/**
* @dev Set/change the Chainlink VRF keyHash
*/
function setVRFKeyHash(bytes32 _keyHash) external onlyAdmin {
VRF_keyHash = _keyHash;
}
/**
* @dev Set/change the Chainlink VRF fee
*/
function setVRFFee(uint256 _fee) external onlyAdmin {
VRF_fee = _fee;
}
/**
* @notice
* - tokenDNA is generated dynamically based on the relevant Chainlink VRF seed. If a token is never
* rerolled, it will be constructed based on period 1 (initial VRF) seed. if a token is rerolled in
* period 5, its DNA will be based on the VRF seed for period 6. This ensures that no one can
* predict or manipulate tokenDNA
* - tokenDNA is generated on the fly and not maintained as state on-chain or off-chain.
* - tokenDNA is used to construct the unique metadata for each NFT
*
* - Some people may not like this function as its based on nested loops, so here is the logic
* 1. this is an external function and is never called by this contract or future contract
* 2. the maximum depth of i will ever be 20, after which all tokenDNA is permanent
* 3. it ensures tokenDNA is always correct under all circumstances
* 4. it has 0 gas implications
*/
function getTokenDNA(uint256 _tId) external view returns (uint256) {
require(_tId < _owners.length, "tokenId out of range");
for (uint256 i = periodCounter; i > 0; i--) {
if (i == 1) {
return uint256(keccak256(abi.encode(collectionDNA[i], _tId)));
} else {
for (uint256 j = 0; j < rollTracker[i].length; j++) {
if (rollTracker[i][j] == _tId) {
return uint256(keccak256(abi.encode(collectionDNA[i], _tId)));
}
}
}
}
}
/**
* @notice To maintain transparency with awarding the "1/1" tokens we are leveraging
* ChainlinkVRF. To accomplish this we are calling requestRandomNumber() after the reveal
* and will use the next periodCounter to derive a fair one of one giveaway.
*/
function get1of1() external view returns (uint256[] memory) {
uint256[] memory oneOfOnes = new uint256[](20);
uint256 counter;
uint256 addCounter;
bool matchStatus;
while (addCounter < 20) {
uint256 result = (uint256(keccak256(abi.encode(collectionDNA[2], counter))) % 8887);
for (uint256 i = 0; i < oneOfOnes.length; i++) {
if (result == oneOfOnes[i]) {
matchStatus = true;
break;
}
}
if (!matchStatus) {
oneOfOnes[addCounter] = result;
addCounter++;
} else {
matchStatus = false;
}
counter++;
}
return oneOfOnes;
}
/**********************************************************
*
* STAKING & UNSTAKING
*
**********************************************************/
/**
* @notice Staking your NFT transfers ownership to (this) contract until you unstake it.
* When an NFT is staked you will earn Goop, which can be used within the illogics
* ecosystem to procure items we have for sale.
*/
function stakeNFT(uint256[] calldata _tokenIds) external {
require(stakingState, "staking not enabled");
for (uint256 i = 0; i < _tokenIds.length; i++) {
require(ownerOf(_tokenIds[i]) == _msgSender(), "you are not the owner");
safeTransferFrom(_msgSender(), address(this), _tokenIds[i]);
stakedToken[_tokenIds[i]].ownerOfNFT = _msgSender();
stakedToken[_tokenIds[i]].timestamp = block.timestamp;
staker[_msgSender()].push(_tokenIds[i]);
}
}
/**
* @notice unstaking a token that has unrealized Goop forfeits the Goop associated
* with the token(s) being unstaked. This was done intentionally as a holder may
* not to pay the gas costs associated with claiming Goop. Please see unstakeAndClaim
* to also claim Goop.
*
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked, you will no longer be earning Goop.
*/
function unstakeNFT(uint256[] calldata _tokenIds) public {
for (uint256 i = 0; i < _tokenIds.length; i++) {
require(stakedToken[_tokenIds[i]].ownerOfNFT == _msgSender(), "you are not the owner");
require(canBeUnstaked(_tokenIds[i]), "token in reroll or cool down period");
_transfer(address(this), _msgSender(), _tokenIds[i]);
delete stakedToken[_tokenIds[i]].ownerOfNFT;
delete stakedToken[_tokenIds[i]].timestamp;
delete stakedToken[_tokenIds[i]].lastRerollPeriod;
/**
* @dev - iterates the array of tokens staked and pops the one being unstaked
*/
for (uint256 j = 0; j < staker[_msgSender()].length; j++) {
if (staker[_msgSender()][j] == _tokenIds[i]) {
staker[_msgSender()][j] = staker[_msgSender()][staker[_msgSender()].length - 1];
staker[_msgSender()].pop();
}
}
}
}
/**
* @dev unstakeAndClaim will unstake the token and realize the Goop that it has earned.
* If you are not interested in earning Goop you can call unstaske and save the gas.
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked you will no longer be earning Goop.
*/
function unstakeAndClaim(uint256[] calldata _tokenIds) external {
claimGoop();
unstakeNFT(_tokenIds);
}
/**
* @notice
* - An address requests a reroll for a tokenId, the tokenDNA is updated after the subsequent VRF request.
* - To prevent the sale of a token prior to the tokenDNA and metadata being refreshed in the marketplace,
* we have implemented a cool-down period. The cool down period will allow a token to be unstaked when
* it is not in the previous period
*/
function canBeUnstaked(uint256 _tokenId) public view returns (bool) {
// token has never been rerolled and can be unstaked
if (stakedToken[_tokenId].lastRerollPeriod == 0) {
return true;
}
// token waiting for next VRF and can not be unstaked
if (stakedToken[_tokenId].lastRerollPeriod == periodCounter) {
return false;
}
// token in cooldown period after the reroll and can not be unstaked
if (periodCounter - stakedToken[_tokenId].lastRerollPeriod == 1) {
return false;
}
return true;
}
/**
* @dev returns an array of tokens that an address has staked
*/
function ownerStaked(address _addr) public view returns (uint256[] memory) {
return staker[_addr];
}
// enables safeTransferFrom function to send ERC721 tokens to this contract (used in staking)
function onERC721Received(
address operator,
address from,
uint256 tId,
bytes calldata data
) external pure returns (bytes4) {
return bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));
}
/**********************************************************
*
* GOOP ECOSYSTEM
*
**********************************************************/
/**
* @notice
* - Goop is an internal point system, there are no goop tokenomics as it
* is minted when claimed and burned when spent. As such the amount of goop
* in circulation is constantly changing.
* - Goop may resemble an ERC20, it can be transferred or donated P2P, however
* it cannot be traded on an exchange and has no monetary value, further it
* can only be used in the illogics ecosystem.
* - Goop exists in 2 forms, claimed and unclaimed, in order to spend goop
* it must be claimed.
*/
/**
* @dev Goop earned as a result of staking but not yet claimed/realized
*/
function unclaimedGoop() external view returns (uint256) {
address addr = _msgSender();
uint256 stakedTime;
for (uint256 i = 0; i < staker[addr].length; i++) {
stakedTime += block.timestamp - stakedToken[staker[addr][i]].timestamp;
}
return (stakedTime / GOOP_INTERVAL) * goopPerInterval;
}
/**
* @dev claim earned Goop without unstaking
*/
function claimGoop() public {
require(claimStatus, "GOOP: claim not enabled");
address addr = _msgSender();
uint256 stakedTime;
for (uint256 i = 0; i < staker[addr].length; i++) {
stakedTime += block.timestamp - stakedToken[staker[addr][i]].timestamp;
stakedToken[staker[addr][i]].timestamp = block.timestamp;
}
_mintGoop(addr, (stakedTime / GOOP_INTERVAL) * goopPerInterval);
}
/**
*
* @dev Moves `amount` Goop from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
*/
function transferGoop(address _to, uint256 _amount) public returns (bool) {
address owner = _msgSender();
_transferGoop(owner, _to, _amount);
return true;
}
/**
* @dev Moves `amount` of Goop from `sender` to `recipient`.
*/
function _transferGoop(
address from,
address to,
uint256 _amount
) internal {
require(transferState, "GOOP: transfer not enabled");
require(from != address(0), "GOOP: transfer from the zero address");
require(to != address(0), "GOOP: transfer to the zero address");
uint256 fromBalance = goop[from];
require(goop[from] >= _amount, "GOOP: insufficient balance ");
unchecked {
goop[from] = fromBalance - _amount;
}
goop[to] += _amount;
}
/**
* @dev admin function to mint Goop to a single address
*/
function mintGoop(address _addr, uint256 _goop) external override onlyAdmin {
_mintGoop(_addr, _goop);
}
/**
* @dev admin function to mint Goop to multiple addresses
*/
function mintGoopBatch(address[] calldata _addr, uint256 _goop) external override onlyAdmin {
for (uint256 i = 0; i < _addr.length; i++) {
_mintGoop(_addr[i], _goop);
}
}
/**
* @dev Creates `amount` Goop and assigns them to `account`
*/
function _mintGoop(address account, uint256 amount) internal {
require(account != address(0), "GOOP: mint to the zero address");
totalGoopSupply += amount;
goop[account] += amount;
}
/**
* @dev admin function to burn Goop from a single address
*/
function burnGoop(address _addr, uint256 _goop) external override onlyAdmin {
_burnGoop(_addr, _goop);
}
/**
* @dev admin function to burn Goop from multiple addresses
*/
function burnGoopBatch(address[] calldata _addr, uint256 _goop) external override onlyAdmin {
for (uint256 i = 0; i < _addr.length; i++) {
_burnGoop(_addr[i], _goop);
}
}
/**
* @dev permits Goop to be spent within the illogics ecosystem
*/
function spendGoop(uint256 _item, uint256 _count) public override {
addressPurchases[_msgSender()][_item] += _count;
require(spendState, "GOOP: spending not enabled");
require(saleItems[_item].saleStatus, "Item not currently for sale");
require(saleItems[_item].supply >= _count, "Item sold out.");
require(addressPurchases[_msgSender()][_item] <= saleItems[_item].maxPurchase, "Exceeded allowed purchase quantity");
uint256 cost = _count * saleItems[_item].price;
require(goop[_msgSender()] >= cost, "Insufficient goop.");
_burnGoop(_msgSender(), cost);
saleItems[_item].supply -= _count;
totalGoopSpent += _count * saleItems[_item].price;
emit spentGoop(_msgSender(), _item, _count);
}
/**
* @dev Destroys `amount` Goop from `account`
*/
function _burnGoop(address account, uint256 amount) internal {
require(account != address(0), "GOOP: burn from the zero address");
uint256 accountBalance = goop[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
goop[account] = accountBalance - amount;
}
totalGoopSupply -= amount;
}
/**********************************************************
*
* GOOP SALE
*
**********************************************************/
/**
* @dev creates a new sale item and sets the sale elements
*/
function createNewSale(
string memory _description,
bool _saleState,
uint256 _price,
uint256 _supply,
uint256 _maxPurchase
) external onlyAdmin {
saleId++;
saleItems[saleId] = Sale(_description, _saleState, _price, _supply, _maxPurchase);
}
/**
* @dev changes the description of the selected item
*/
function setSaleDescription(uint256 _item, string memory _description) external onlyAdmin {
saleItems[_item].description = _description;
}
/**
* @dev enable/disable the sale of the selected item
*/
function setSaleStatus(uint256 _item, bool _saleStatus) external onlyAdmin {
saleItems[_item].saleStatus = _saleStatus;
}
/**
* @dev changes the sale price of the selected item
*/
function setSalePrice(uint256 _item, uint256 _price) external onlyAdmin {
saleItems[_item].price = _price;
}
/**
* @dev changes supply of the selected item
*/
function setSaleSupply(uint256 _item, uint256 _supply) external onlyAdmin {
saleItems[_item].supply = _supply;
}
/**
* @dev changes the max amount an address can purchase of the selected item
*/
function setMaxPurchase(uint256 _item, uint256 _maxPurchase) external onlyAdmin {
saleItems[_item].maxPurchase = _maxPurchase;
}
/**********************************************************
*
* OPENSEA
*
**********************************************************/
function setProxyRegistryAddress(address _proxyRegistryAddress) external onlyAdmin {
proxyRegistryAddress = _proxyRegistryAddress;
}
function flipProxyState(address proxyAddress) public onlyOwner {
projectProxy[proxyAddress] = !projectProxy[proxyAddress];
}
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
OpenSeaProxyRegistry proxyRegistry = OpenSeaProxyRegistry(proxyRegistryAddress);
if (address(proxyRegistry.proxies(_owner)) == operator || projectProxy[operator]) return true;
return super.isApprovedForAll(_owner, operator);
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
} | * @notice A reroll is an opportunity to change your tokenDNA and only available when reroll is enabled. A token that is rerolled gets brand new tokenDNA that is generated in the next reroll period with the result of the Chainlink VRF requestRandomNumber(). Its impossible to know the result of your reroll in advance of the Chainlink call and as a result you may end up with a rarer or less rare tokenDNA./ | function reroll(uint256[] calldata _tokenIds) external {
uint256 amount = REROLL_COST * _tokenIds.length;
require(rerollState, "reroll not enabled");
require(goop[_msgSender()] >= amount, "not enough goop for reroll");
for (uint256 i = 0; i < _tokenIds.length; i++) {
require(stakedToken[_tokenIds[i]].ownerOfNFT == _msgSender(), "you dont own this token or its not staked");
rollTracker[periodCounter + 1].push(_tokenIds[i]);
stakedToken[_tokenIds[i]].lastRerollPeriod = periodCounter;
}
_burnGoop(_msgSender(), amount);
}
| 13,679,455 | [
1,
37,
436,
264,
22382,
353,
392,
1061,
655,
13352,
358,
2549,
3433,
1147,
8609,
37,
471,
1338,
2319,
1347,
436,
264,
22382,
353,
3696,
18,
225,
432,
1147,
716,
353,
436,
264,
355,
1259,
5571,
15272,
394,
1147,
8609,
37,
716,
353,
4374,
316,
326,
1024,
436,
264,
22382,
3879,
225,
598,
326,
563,
434,
326,
7824,
1232,
776,
12918,
590,
8529,
1854,
7675,
29517,
23343,
358,
5055,
326,
563,
225,
434,
3433,
436,
264,
22382,
316,
8312,
434,
326,
7824,
1232,
745,
471,
487,
279,
563,
1846,
2026,
679,
731,
598,
279,
436,
14500,
225,
578,
5242,
25671,
1147,
8609,
37,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
436,
264,
22382,
12,
11890,
5034,
8526,
745,
892,
389,
2316,
2673,
13,
3903,
288,
203,
3639,
2254,
5034,
3844,
273,
534,
654,
30922,
67,
28343,
380,
389,
2316,
2673,
18,
2469,
31,
203,
3639,
2583,
12,
86,
264,
22382,
1119,
16,
315,
86,
264,
22382,
486,
3696,
8863,
203,
3639,
2583,
12,
3240,
556,
63,
67,
3576,
12021,
1435,
65,
1545,
3844,
16,
315,
902,
7304,
1960,
556,
364,
436,
264,
22382,
8863,
203,
203,
1850,
364,
261,
11890,
5034,
277,
273,
374,
31,
277,
411,
389,
2316,
2673,
18,
2469,
31,
277,
27245,
288,
203,
203,
5411,
2583,
12,
334,
9477,
1345,
63,
67,
2316,
2673,
63,
77,
65,
8009,
8443,
951,
50,
4464,
422,
389,
3576,
12021,
9334,
315,
19940,
14046,
4953,
333,
1147,
578,
2097,
486,
384,
9477,
8863,
203,
203,
5411,
5824,
8135,
63,
6908,
4789,
397,
404,
8009,
6206,
24899,
2316,
2673,
63,
77,
19226,
203,
5411,
384,
9477,
1345,
63,
67,
2316,
2673,
63,
77,
65,
8009,
2722,
54,
264,
22382,
5027,
273,
3879,
4789,
31,
203,
3639,
289,
203,
203,
3639,
389,
70,
321,
5741,
556,
24899,
3576,
12021,
9334,
3844,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/1/0xFC047884dE7797A3D9cbA42FBc3b675388A110d5/sources/contracts/polygon/tunnel/FxBaseRootTunnel.sol | keccak256(MessageSent(bytes)) state sender contract root chain manager child tunnel contract which receives and sends messages storage to avoid duplicate exits | abstract contract FxBaseRootTunnel {
using RLPReader for RLPReader.RLPItem;
using Merkle for bytes32;
using ExitPayloadReader for bytes;
using ExitPayloadReader for ExitPayloadReader.ExitPayload;
using ExitPayloadReader for ExitPayloadReader.Log;
using ExitPayloadReader for ExitPayloadReader.LogTopics;
using ExitPayloadReader for ExitPayloadReader.Receipt;
bytes32 public constant SEND_MESSAGE_EVENT_SIG = 0x8c5261668696ce22758910d05bab8f186d6eb247ceac2af2e82c7dc17669b036;
IFxStateSender public fxRoot;
ICheckpointManager public checkpointManager;
address public fxChildTunnel;
mapping(bytes32 => bool) public processedExits;
constructor(address _checkpointManager, address _fxRoot) {
checkpointManager = ICheckpointManager(_checkpointManager);
fxRoot = IFxStateSender(_fxRoot);
}
function setFxChildTunnel(address _fxChildTunnel) public {
require(fxChildTunnel == address(0x0), "FxBaseRootTunnel: CHILD_TUNNEL_ALREADY_SET");
fxChildTunnel = _fxChildTunnel;
}
function _sendMessageToChild(bytes memory message) internal {
fxRoot.sendMessageToChild(fxChildTunnel, message);
}
function _validateAndExtractMessage(bytes memory inputData) internal returns (bytes memory) {
ExitPayloadReader.ExitPayload memory payload = inputData.toExitPayload();
bytes memory branchMaskBytes = payload.getBranchMaskAsBytes();
uint256 blockNumber = payload.getBlockNumber();
bytes32 exitHash = keccak256(
abi.encodePacked(
blockNumber,
MerklePatriciaProof._getNibbleArray(branchMaskBytes),
payload.getReceiptLogIndex()
)
);
require(processedExits[exitHash] == false, "FxRootTunnel: EXIT_ALREADY_PROCESSED");
processedExits[exitHash] = true;
ExitPayloadReader.Receipt memory receipt = payload.getReceipt();
ExitPayloadReader.Log memory log = receipt.getLog();
require(fxChildTunnel == log.getEmitter(), "FxRootTunnel: INVALID_FX_CHILD_TUNNEL");
bytes32 receiptRoot = payload.getReceiptRoot();
require(
MerklePatriciaProof.verify(receipt.toBytes(), branchMaskBytes, payload.getReceiptProof(), receiptRoot),
"FxRootTunnel: INVALID_RECEIPT_PROOF"
);
_checkBlockMembershipInCheckpoint(
blockNumber,
payload.getBlockTime(),
payload.getTxRoot(),
receiptRoot,
payload.getHeaderNumber(),
payload.getBlockProof()
);
ExitPayloadReader.LogTopics memory topics = log.getTopics();
require(
"FxRootTunnel: INVALID_SIGNATURE"
);
return message;
}
function _checkBlockMembershipInCheckpoint(
uint256 blockNumber,
uint256 blockTime,
bytes32 txRoot,
bytes32 receiptRoot,
uint256 headerNumber,
bytes memory blockProof
) private view returns (uint256) {
(bytes32 headerRoot, uint256 startBlock, , uint256 createdAt, ) = checkpointManager.headerBlocks(headerNumber);
require(
keccak256(abi.encodePacked(blockNumber, blockTime, txRoot, receiptRoot)).checkMembership(
blockNumber - startBlock,
headerRoot,
blockProof
),
"FxRootTunnel: INVALID_HEADER"
);
return createdAt;
}
function receiveMessage(bytes memory inputData) public virtual {
bytes memory message = _validateAndExtractMessage(inputData);
_processMessageFromChild(message);
}
} | 16,474,351 | [
1,
79,
24410,
581,
5034,
12,
1079,
7828,
12,
3890,
3719,
919,
5793,
6835,
1365,
2687,
3301,
1151,
14825,
6835,
1492,
17024,
471,
9573,
2743,
2502,
358,
4543,
6751,
19526,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
17801,
6835,
478,
92,
2171,
2375,
20329,
288,
203,
565,
1450,
534,
14461,
2514,
364,
534,
14461,
2514,
18,
54,
48,
1102,
874,
31,
203,
565,
1450,
31827,
364,
1731,
1578,
31,
203,
565,
1450,
9500,
6110,
2514,
364,
1731,
31,
203,
565,
1450,
9500,
6110,
2514,
364,
9500,
6110,
2514,
18,
6767,
6110,
31,
203,
565,
1450,
9500,
6110,
2514,
364,
9500,
6110,
2514,
18,
1343,
31,
203,
565,
1450,
9500,
6110,
2514,
364,
9500,
6110,
2514,
18,
1343,
17477,
31,
203,
565,
1450,
9500,
6110,
2514,
364,
9500,
6110,
2514,
18,
15636,
31,
203,
203,
565,
1731,
1578,
1071,
5381,
31434,
67,
8723,
67,
10454,
67,
18513,
273,
374,
92,
28,
71,
25,
5558,
23553,
5292,
10525,
311,
3787,
5877,
6675,
2163,
72,
6260,
70,
378,
28,
74,
2643,
26,
72,
26,
24008,
3247,
27,
311,
1077,
22,
1727,
22,
73,
11149,
71,
27,
7201,
4033,
6028,
29,
70,
4630,
26,
31,
203,
203,
565,
11083,
92,
1119,
12021,
1071,
12661,
2375,
31,
203,
565,
467,
14431,
1318,
1071,
9776,
1318,
31,
203,
565,
1758,
1071,
12661,
1763,
20329,
31,
203,
203,
565,
2874,
12,
3890,
1578,
516,
1426,
13,
1071,
5204,
424,
1282,
31,
203,
203,
565,
3885,
12,
2867,
389,
25414,
1318,
16,
1758,
389,
19595,
2375,
13,
288,
203,
3639,
9776,
1318,
273,
467,
14431,
1318,
24899,
25414,
1318,
1769,
203,
3639,
12661,
2375,
273,
11083,
92,
1119,
12021,
24899,
19595,
2375,
1769,
203,
565,
289,
203,
203,
565,
445,
24340,
92,
1763,
20329,
12,
2867,
389,
19595,
1763,
2
] |
./partial_match/1/0xCAE8c981bA27db88b988bbc2d6b52987586cf32B/sources/FOPToken.sol | * @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 {
pragma solidity 0.8.19;
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
| 3,881,619 | [
1,
17727,
1779,
2973,
326,
783,
4588,
819,
16,
6508,
326,
5793,
434,
326,
2492,
471,
2097,
501,
18,
21572,
4259,
854,
19190,
2319,
3970,
1234,
18,
15330,
471,
1234,
18,
892,
16,
2898,
1410,
486,
506,
15539,
316,
4123,
279,
2657,
21296,
16,
3241,
1347,
21964,
598,
2191,
17,
20376,
326,
2236,
5431,
471,
8843,
310,
364,
4588,
2026,
486,
506,
326,
3214,
5793,
261,
345,
10247,
487,
392,
2521,
353,
356,
2750,
11748,
2934,
1220,
6835,
353,
1338,
1931,
364,
12110,
16,
5313,
17,
5625,
20092,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
17801,
6835,
1772,
288,
203,
203,
203,
683,
9454,
18035,
560,
374,
18,
28,
18,
3657,
31,
203,
565,
445,
389,
3576,
12021,
1435,
2713,
1476,
5024,
1135,
261,
2867,
13,
288,
203,
3639,
327,
1234,
18,
15330,
31,
203,
565,
289,
203,
7010,
565,
445,
389,
3576,
751,
1435,
2713,
1476,
5024,
1135,
261,
3890,
745,
892,
13,
288,
203,
3639,
327,
1234,
18,
892,
31,
203,
565,
289,
203,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import "@paulrberg/contracts/token/erc20/Erc20Permit.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Banny is ERC20, ERC20Permit, Ownable {
constructor() ERC20("Banny", "BANNY") ERC20Permit("Banny") {}
function mint(address _account, uint256 _amount) external onlyOwner {
return _mint(_account, _amount);
}
function burn(address _account, uint256 _amount) external onlyOwner {
return _burn(_account, _amount);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
/**
* @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 default 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
* overridden;
*
* 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");
unchecked {
_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");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This 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");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(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:
*
* - `account` 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);
_afterTokenTransfer(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");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(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 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 Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./draft-IERC20Permit.sol";
import "../ERC20.sol";
import "../../../utils/cryptography/draft-EIP712.sol";
import "../../../utils/cryptography/ECDSA.sol";
import "../../../utils/Counters.sol";
/**
* @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*
* _Available since v3.4._
*/
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private immutable _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/**
* @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
*
* It's a good idea to use the same `name` that is defined as the ERC20 token name.
*/
constructor(string memory name) EIP712(name, "1") {}
/**
* @dev See {IERC20Permit-permit}.
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
/**
* @dev See {IERC20Permit-nonces}.
*/
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
/**
* @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
/**
* @dev "Consume a nonce": return the current value and increment.
*
* _Available since v4.1._
*/
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
// SPDX-License-Identifier: WTFPL
// solhint-disable var-name-mixedcase
pragma solidity >=0.8.4;
import "./Erc20.sol";
import "./IErc20Permit.sol";
/// @notice Emitted when the recovered owner does not match the actual owner.
error Erc20Permit__InvalidSignature(uint8 v, bytes32 r, bytes32 s);
/// @notice Emitted when the owner is the zero address.
error Erc20Permit__OwnerZeroAddress();
/// @notice Emitted when the permit expired.
error Erc20Permit__PermitExpired(uint256 deadline);
/// @notice Emitted when the recovered owner is the zero address.
error Erc20Permit__RecoveredOwnerZeroAddress();
/// @notice Emitted when the spender is the zero address.
error Erc20Permit__SpenderZeroAddress();
/// @title Erc20Permit
/// @author Paul Razvan Berg
contract Erc20Permit is
IErc20Permit, // one dependency
Erc20 // one dependency
{
/// PUBLIC STORAGE ///
/// @inheritdoc IErc20Permit
bytes32 public immutable override DOMAIN_SEPARATOR;
/// @inheritdoc IErc20Permit
bytes32 public constant override PERMIT_TYPEHASH =
0xfc77c2b9d30fe91687fd39abb7d16fcdfe1472d065740051ab8b13e4bf4a617f;
/// @inheritdoc IErc20Permit
mapping(address => uint256) public override nonces;
/// @inheritdoc IErc20Permit
string public constant override version = "1";
/// CONSTRUCTOR ///
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) Erc20(_name, _symbol, _decimals) {
uint256 chainId;
// solhint-disable-next-line no-inline-assembly
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes(version)),
chainId,
address(this)
)
);
}
/// PUBLIC NON-CONSTANT FUNCTIONS ///
/// @inheritdoc IErc20Permit
function permit(
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external override {
if (owner == address(0)) {
revert Erc20Permit__OwnerZeroAddress();
}
if (spender == address(0)) {
revert Erc20Permit__SpenderZeroAddress();
}
if (deadline < block.timestamp) {
revert Erc20Permit__PermitExpired(deadline);
}
// It's safe to use the "+" operator here because the nonce cannot realistically overflow, ever.
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hashStruct));
address recoveredOwner = ecrecover(digest, v, r, s);
if (recoveredOwner == address(0)) {
revert Erc20Permit__RecoveredOwnerZeroAddress();
}
if (recoveredOwner != owner) {
revert Erc20Permit__InvalidSignature(v, r, s);
}
approveInternal(owner, spender, amount);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @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.
*/
abstract 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() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.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);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
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);
}
// 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) {
return msg.data;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ECDSA.sol";
/**
* @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
*
* The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
* thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
* they need in their contracts using a combination of `abi.encode` and `keccak256`.
*
* This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
* scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
* ({_hashTypedDataV4}).
*
* The implementation of the domain separator was designed to be as efficient as possible while still properly updating
* the chain id to protect against replay attacks on an eventual fork of the chain.
*
* NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
* https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
*
* _Available since v3.4._
*/
abstract contract EIP712 {
/* solhint-disable var-name-mixedcase */
// Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
/* solhint-enable var-name-mixedcase */
/**
* @dev Initializes the domain separator and parameter caches.
*
* The meaning of `name` and `version` is specified in
* https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
*
* - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
* - `version`: the current major version of the signing domain.
*
* NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
* contract upgrade].
*/
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
);
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
/**
* @dev Returns the domain separator for the current chain.
*/
function _domainSeparatorV4() internal view returns (bytes32) {
if (block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(
bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash
) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
/**
* @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
* function returns the hash of the fully encoded EIP712 message for this domain.
*
* This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
*
* ```solidity
* bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
* keccak256("Mail(address to,string contents)"),
* mailTo,
* keccak256(bytes(mailContents))
* )));
* address signer = ECDSA.recover(digest, signature);
* ```
*/
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSA {
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return recover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return recover(hash, r, vs);
} else {
revert("ECDSA: invalid signature length");
}
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*
* _Available since v4.2._
*/
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return recover(hash, v, r, s);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`, `r` and `s` signature fields separately.
*/
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (281): 0 < s < secp256k1n รท 2 + 1, and for v in (282): v โ {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
require(
uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
"ECDSA: invalid signature 's' value"
);
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
/**
* @dev Returns an Ethereum Signed Message, created from a `hash`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
/**
* @dev Returns an Ethereum Signed Typed Data, created from a
* `domainSeparator` and a `structHash`. This produces hash corresponding
* to the one signed with the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
* JSON-RPC method as part of EIP-712.
*
* See {recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. 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;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
// SPDX-License-Identifier: WTFPL
pragma solidity >=0.8.4;
import "./IErc20.sol";
/// @notice Emitted when the owner is the zero address.
error Erc20__ApproveOwnerZeroAddress();
/// @notice Emitted when the spender is the zero address.
error Erc20__ApproveSpenderZeroAddress();
/// @notice Emitted when burning more tokens than are in the account.
error Erc20__BurnUnderflow(uint256 accountBalance, uint256 burnAmount);
/// @notice Emitted when the holder is the zero address.
error Erc20__BurnZeroAddress();
/// @notice Emitted when the sender did not give the caller a sufficient allowance.
error Erc20__InsufficientAllowance(uint256 allowance, uint256 amount);
/// @notice Emitted when the beneficiary is the zero address.
error Erc20__MintZeroAddress();
/// @notice Emitted when tranferring more tokens than there are in the account.
error Erc20__TransferUnderflow(uint256 senderBalance, uint256 amount);
/// @notice Emitted when the sender is the zero address.
error Erc20__TransferSenderZeroAddress();
/// @notice Emitted when the recipient is the zero address.
error Erc20__TransferRecipientZeroAddress();
/// @title Erc20
/// @author Paul Razvan Berg
contract Erc20 is IErc20 {
/// PUBLIC STORAGE ///
/// @inheritdoc IErc20
string public override name;
/// @inheritdoc IErc20
string public override symbol;
/// @inheritdoc IErc20
uint8 public immutable override decimals;
/// @inheritdoc IErc20
uint256 public override totalSupply;
/// @inheritdoc IErc20
mapping(address => uint256) public override balanceOf;
/// @inheritdoc IErc20
mapping(address => mapping(address => uint256)) public override allowance;
/// CONSTRUCTOR ///
/// @notice All three of these values are immutable: they can only be set once during construction.
/// @param _name Erc20 name of this token.
/// @param _symbol Erc20 symbol of this token.
/// @param _decimals Erc20 decimal precision of this token.
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
/// PUBLIC NON-CONSTANT FUNCTIONS ///
/// @inheritdoc IErc20
function approve(address spender, uint256 amount) external virtual override returns (bool) {
approveInternal(msg.sender, spender, amount);
return true;
}
/// @inheritdoc IErc20
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual override returns (bool) {
uint256 newAllowance = allowance[msg.sender][spender] - subtractedValue;
approveInternal(msg.sender, spender, newAllowance);
return true;
}
/// @inheritdoc IErc20
function increaseAllowance(address spender, uint256 addedValue) external virtual override returns (bool) {
uint256 newAllowance = allowance[msg.sender][spender] + addedValue;
approveInternal(msg.sender, spender, newAllowance);
return true;
}
/// @inheritdoc IErc20
function transfer(address recipient, uint256 amount) external virtual override returns (bool) {
transferInternal(msg.sender, recipient, amount);
return true;
}
/// @inheritdoc IErc20
function transferFrom(
address sender,
address recipient,
uint256 amount
) external virtual override returns (bool) {
transferInternal(sender, recipient, amount);
uint256 currentAllowance = allowance[sender][msg.sender];
if (currentAllowance < amount) {
revert Erc20__InsufficientAllowance(currentAllowance, amount);
}
approveInternal(sender, msg.sender, currentAllowance);
return true;
}
/// INTERNAL NON-CONSTANT FUNCTIONS ///
/// @notice Sets `amount` as the allowance of `spender` over the `owner`s tokens.
///
/// @dev Emits an {Approval} event.
///
/// This is internal function is equivalent to `approve`, and can be used to e.g. set automatic
/// allowances for certain subsystems, etc.
///
/// Requirements:
///
/// - `owner` cannot be the zero address.
/// - `spender` cannot be the zero address.
function approveInternal(
address owner,
address spender,
uint256 amount
) internal virtual {
if (owner == address(0)) {
revert Erc20__ApproveOwnerZeroAddress();
}
if (spender == address(0)) {
revert Erc20__ApproveSpenderZeroAddress();
}
allowance[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/// @notice Destroys `burnAmount` tokens from `holder`, reducing the token supply.
///
/// @dev Emits a {Transfer} event.
///
/// Requirements:
///
/// - `holder` must have at least `amount` tokens.
function burnInternal(address holder, uint256 burnAmount) internal {
if (holder == address(0)) {
revert Erc20__BurnZeroAddress();
}
uint256 accountBalance = balanceOf[holder];
if (accountBalance < burnAmount) {
revert Erc20__BurnUnderflow(accountBalance, burnAmount);
}
// Burn the tokens.
unchecked {
balanceOf[holder] = accountBalance - burnAmount;
}
// Reduce the total supply.
totalSupply -= burnAmount;
emit Transfer(holder, address(0), burnAmount);
}
/// @notice Prints new tokens into existence and assigns them to `beneficiary`, increasing the
/// total supply.
///
/// @dev Emits a {Transfer} event.
///
/// Requirements:
///
/// - The beneficiary's balance and the total supply cannot overflow.
function mintInternal(address beneficiary, uint256 mintAmount) internal {
if (beneficiary == address(0)) {
revert Erc20__MintZeroAddress();
}
/// Mint the new tokens.
balanceOf[beneficiary] += mintAmount;
/// Increase the total supply.
totalSupply += mintAmount;
emit Transfer(address(0), beneficiary, mintAmount);
}
/// @notice Moves `amount` tokens from `sender` to `recipient`.
///
/// @dev 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 transferInternal(
address sender,
address recipient,
uint256 amount
) internal virtual {
if (sender == address(0)) {
revert Erc20__TransferSenderZeroAddress();
}
if (recipient == address(0)) {
revert Erc20__TransferRecipientZeroAddress();
}
uint256 senderBalance = balanceOf[sender];
if (senderBalance < amount) {
revert Erc20__TransferUnderflow(senderBalance, amount);
}
unchecked {
balanceOf[sender] = senderBalance - amount;
}
balanceOf[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
}
// SPDX-License-Identifier: WTFPL
// solhint-disable func-name-mixedcase
pragma solidity >=0.8.4;
import "./IErc20.sol";
/// @title IErc20Permit
/// @author Paul Razvan Berg
/// @notice Extension of Erc20 that allows token holders to use their tokens without sending any
/// transactions by setting the allowance with a signature using the `permit` method, and then spend
/// them via `transferFrom`.
/// @dev See https://eips.ethereum.org/EIPS/eip-2612.
interface IErc20Permit is IErc20 {
/// NON-CONSTANT FUNCTIONS ///
/// @notice Sets `amount` as the allowance of `spender` over `owner`'s tokens, assuming the latter's
/// signed approval.
///
/// @dev Emits an {Approval} event.
///
/// IMPORTANT: The same issues Erc20 `approve` has related to transaction
/// ordering also apply here.
///
/// Requirements:
///
/// - `owner` cannot be the zero address.
/// - `spender` cannot be the zero address.
/// - `deadline` must be a timestamp in the future.
/// - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` over the Eip712-formatted
/// function arguments.
/// - The signature must use `owner`'s current nonce.
function permit(
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/// CONSTANT FUNCTIONS ///
/// @notice The Eip712 domain's keccak256 hash.
function DOMAIN_SEPARATOR() external view returns (bytes32);
/// @notice Provides replay protection.
function nonces(address account) external view returns (uint256);
/// @notice keccak256("Permit(address owner,address spender,uint256 amount,uint256 nonce,uint256 deadline)");
function PERMIT_TYPEHASH() external view returns (bytes32);
/// @notice Eip712 version of this implementation.
function version() external view returns (string memory);
}
// SPDX-License-Identifier: WTFPL
pragma solidity >=0.8.4;
/// @title IErc20
/// @author Paul Razvan Berg
/// @notice Implementation for the Erc20 standard.
///
/// 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 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 Erc 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.
///
/// @dev Forked from OpenZeppelin
/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC20/ERC20.sol
interface IErc20 {
/// EVENTS ///
/// @notice Emitted when an approval happens.
/// @param owner The address of the owner of the tokens.
/// @param spender The address of the spender.
/// @param amount The maximum amount that can be spent.
event Approval(address indexed owner, address indexed spender, uint256 amount);
/// @notice Emitted when a transfer happens.
/// @param from The account sending the tokens.
/// @param to The account receiving the tokens.
/// @param amount The amount of tokens transferred.
event Transfer(address indexed from, address indexed to, uint256 amount);
/// CONSTANT FUNCTIONS ///
/// @notice Returns the remaining number of tokens that `spender` will be allowed to spend
/// on behalf of `owner` through {transferFrom}. This is zero by default.
///
/// @dev This value changes when {approve} or {transferFrom} are called.
function allowance(address owner, address spender) external view returns (uint256);
/// @notice Returns the amount of tokens owned by `account`.
function balanceOf(address account) external view returns (uint256);
/// @notice Returns the number of decimals used to get its user representation.
function decimals() external view returns (uint8);
/// @notice Returns the name of the token.
function name() external view returns (string memory);
/// @notice Returns the symbol of the token, usually a shorter version of the name.
function symbol() external view returns (string memory);
/// @notice Returns the amount of tokens in existence.
function totalSupply() external view returns (uint256);
/// NON-CONSTANT FUNCTIONS ///
/// @notice Sets `amount` as the allowance of `spender` over the caller's tokens.
///
/// @dev Emits an {Approval} event.
///
/// 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
///
/// Requirements:
///
/// - `spender` cannot be the zero address.
///
/// @return a boolean value indicating whether the operation succeeded.
function approve(address spender, uint256 amount) external returns (bool);
/// @notice Atomically decreases the allowance granted to `spender` by the caller.
///
/// @dev Emits an {Approval} event indicating the updated allowance.
///
/// This is an alternative to {approve} that can be used as a mitigation for problems described
/// in {Erc20Interface-approve}.
///
/// Requirements:
///
/// - `spender` cannot be the zero address.
/// - `spender` must have allowance for the caller of at least `subtractedValue`.
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
/// @notice Atomically increases the allowance granted to `spender` by the caller.
///
/// @dev Emits an {Approval} event indicating the updated allowance.
///
/// This is an alternative to {approve} that can be used as a mitigation for the problems described above.
///
/// Requirements:
///
/// - `spender` cannot be the zero address.
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
/// @notice Moves `amount` tokens from the caller's account to `recipient`.
///
/// @dev Emits a {Transfer} event.
///
/// Requirements:
///
/// - `recipient` cannot be the zero address.
/// - The caller must have a balance of at least `amount`.
///
/// @return a boolean value indicating whether the operation succeeded.
function transfer(address recipient, uint256 amount) external returns (bool);
/// @notice Moves `amount` tokens from `sender` to `recipient` using the allowance mechanism. `amount`
/// `is then deducted from the caller's allowance.
///
/// @dev Emits a {Transfer} event and an {Approval} event indicating the updated allowance. This is
/// not required by the Erc. 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 approed `sender` to spent at least `amount` tokens.
///
/// @return a boolean value indicating whether the operation succeeded.
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
}
| @notice Emitted when the sender is the zero address. | error Erc20__TransferSenderZeroAddress();
| 402,818 | [
1,
1514,
11541,
1347,
326,
5793,
353,
326,
3634,
1758,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1636,
512,
1310,
3462,
972,
5912,
12021,
7170,
1887,
5621,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
/**
*Submitted for verification at Etherscan.io on 2022-02-03
*/
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// Global Enums and Structs
struct StrategyParams {
uint256 performanceFee;
uint256 activation;
uint256 debtRatio;
uint256 minDebtPerHarvest;
uint256 maxDebtPerHarvest;
uint256 lastReport;
uint256 totalDebt;
uint256 totalGain;
uint256 totalLoss;
}
// Part: IAddressResolver
// https://docs.synthetix.io/contracts/source/interfaces/iaddressresolver
interface IAddressResolver {
function getAddress(bytes32 name) external view returns (address);
function getSynth(bytes32 key) external view returns (address);
function requireAndGetAddress(bytes32 name, string calldata reason)
external
view
returns (address);
}
// Part: IBaseFee
interface IBaseFee {
function isCurrentBaseFeeAcceptable() external view returns (bool);
}
// Part: IConvexDeposit
interface IConvexDeposit {
// deposit into convex, receive a tokenized deposit. parameter to stake immediately (we always do this).
function deposit(
uint256 _pid,
uint256 _amount,
bool _stake
) external returns (bool);
// burn a tokenized deposit (Convex deposit tokens) to receive curve lp tokens back
function withdraw(uint256 _pid, uint256 _amount) external returns (bool);
// give us info about a pool based on its pid
function poolInfo(uint256)
external
view
returns (
address,
address,
address,
address,
address,
bool
);
}
// Part: IConvexRewards
interface IConvexRewards {
// strategy's staked balance in the synthetix staking contract
function balanceOf(address account) external view returns (uint256);
// read how much claimable CRV a strategy has
function earned(address account) external view returns (uint256);
// stake a convex tokenized deposit
function stake(uint256 _amount) external returns (bool);
// withdraw to a convex tokenized deposit, probably never need to use this
function withdraw(uint256 _amount, bool _claim) external returns (bool);
// withdraw directly to curve LP token, this is what we primarily use
function withdrawAndUnwrap(uint256 _amount, bool _claim)
external
returns (bool);
// claim rewards, with an option to claim extra rewards or not
function getReward(address _account, bool _claimExtras)
external
returns (bool);
// if we have rewards, see what the address is
function extraRewards(uint256 _reward) external view returns (address);
// read our rewards token
function rewardToken() external view returns (address);
// check our reward period finish
function periodFinish() external view returns (uint256);
}
// Part: IOracle
interface IOracle {
function latestAnswer() external view returns (uint256);
}
// Part: IReadProxy
interface IReadProxy {
function target() external view returns (address);
function balanceOf(address owner) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
}
// Part: ISynth
interface ISynth {
// Views
function currencyKey() external view returns (bytes32);
function transferableSynths(address account)
external
view
returns (uint256);
// Mutative functions
function transferAndSettle(address to, uint256 value)
external
returns (bool);
function transferFromAndSettle(
address from,
address to,
uint256 value
) external returns (bool);
// Restricted: used internally to Synthetix
function burn(address account, uint256 amount) external;
function issue(address account, uint256 amount) external;
}
// Part: ISynthetix
// https://docs.synthetix.io/contracts/source/interfaces/isynthetix
interface ISynthetix {
// Views
function anySynthOrSNXRateIsInvalid()
external
view
returns (bool anyRateInvalid);
function availableCurrencyKeys() external view returns (bytes32[] memory);
function availableSynthCount() external view returns (uint256);
function collateral(address account) external view returns (uint256);
function collateralisationRatio(address issuer)
external
view
returns (uint256);
function debtBalanceOf(address issuer, bytes32 currencyKey)
external
view
returns (uint256);
function isWaitingPeriod(bytes32 currencyKey) external view returns (bool);
function maxIssuableSynths(address issuer)
external
view
returns (uint256 maxIssuable);
function remainingIssuableSynths(address issuer)
external
view
returns (
uint256 maxIssuable,
uint256 alreadyIssued,
uint256 totalSystemDebt
);
function synthsByAddress(address synthAddress)
external
view
returns (bytes32);
function totalIssuedSynths(bytes32 currencyKey)
external
view
returns (uint256);
function totalIssuedSynthsExcludeEtherCollateral(bytes32 currencyKey)
external
view
returns (uint256);
function transferableSynthetix(address account)
external
view
returns (uint256 transferable);
// Mutative Functions
function burnSynths(uint256 amount) external;
function burnSynthsOnBehalf(address burnForAddress, uint256 amount)
external;
function burnSynthsToTarget() external;
function burnSynthsToTargetOnBehalf(address burnForAddress) external;
function exchange(
bytes32 sourceCurrencyKey,
uint256 sourceAmount,
bytes32 destinationCurrencyKey
) external returns (uint256 amountReceived);
function exchangeOnBehalf(
address exchangeForAddress,
bytes32 sourceCurrencyKey,
uint256 sourceAmount,
bytes32 destinationCurrencyKey
) external returns (uint256 amountReceived);
function exchangeWithTracking(
bytes32 sourceCurrencyKey,
uint256 sourceAmount,
bytes32 destinationCurrencyKey,
address originator,
bytes32 trackingCode
) external returns (uint256 amountReceived);
function exchangeOnBehalfWithTracking(
address exchangeForAddress,
bytes32 sourceCurrencyKey,
uint256 sourceAmount,
bytes32 destinationCurrencyKey,
address originator,
bytes32 trackingCode
) external returns (uint256 amountReceived);
function exchangeWithTrackingForInitiator(
bytes32 sourceCurrencyKey,
uint256 sourceAmount,
bytes32 destinationCurrencyKey,
address rewardAddress,
bytes32 trackingCode
) external returns (uint256 amountReceived);
function issueMaxSynths() external;
function issueMaxSynthsOnBehalf(address issueForAddress) external;
function issueSynths(uint256 amount) external;
function issueSynthsOnBehalf(address issueForAddress, uint256 amount)
external;
function mint() external returns (bool);
function settle(bytes32 currencyKey)
external
returns (
uint256 reclaimed,
uint256 refunded,
uint256 numEntries
);
// Liquidations
function liquidateDelinquentAccount(address account, uint256 susdAmount)
external
returns (bool);
// Restricted Functions
function mintSecondary(address account, uint256 amount) external;
function mintSecondaryRewards(uint256 amount) external;
function burnSecondary(address account, uint256 amount) external;
}
// Part: ISystemStatus
interface ISystemStatus {
function getSynthExchangeSuspensions(bytes32[] calldata synths)
external
view
returns (bool[] memory exchangeSuspensions, uint256[] memory reasons);
}
// Part: IUniV3
interface IUniV3 {
struct ExactInputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
}
function exactInput(ExactInputParams calldata params)
external
payable
returns (uint256 amountOut);
}
// Part: IWeth
interface IWeth {
function withdraw(uint256 wad) external;
}
// Part: OpenZeppelin/[emailย protected]/Address
/**
* @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);
}
}
}
}
// Part: OpenZeppelin/[emailย protected]/IERC20
/**
* @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);
}
// Part: OpenZeppelin/[emailย protected]/Math
/**
* @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);
}
}
// Part: OpenZeppelin/[emailย protected]/SafeMath
/**
* @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;
}
}
// Part: yearn/[emailย protected]/HealthCheck
interface HealthCheck {
function check(
uint256 profit,
uint256 loss,
uint256 debtPayment,
uint256 debtOutstanding,
uint256 totalDebt
) external view returns (bool);
}
// Part: ICurveFi
interface ICurveFi is IERC20 {
function get_virtual_price() external view returns (uint256);
function coins(uint256) external view returns (address);
function add_liquidity(
// EURt
uint256[2] calldata amounts,
uint256 min_mint_amount
) external payable;
function add_liquidity(
// Compound, sAave
uint256[2] calldata amounts,
uint256 min_mint_amount,
bool _use_underlying
) external payable returns (uint256);
function add_liquidity(
// Iron Bank, Aave
uint256[3] calldata amounts,
uint256 min_mint_amount,
bool _use_underlying
) external payable returns (uint256);
function add_liquidity(
// 3Crv Metapools
address pool,
uint256[4] calldata amounts,
uint256 min_mint_amount
) external;
function add_liquidity(
// Y and yBUSD
uint256[4] calldata amounts,
uint256 min_mint_amount,
bool _use_underlying
) external payable returns (uint256);
function add_liquidity(
// 3pool
uint256[3] calldata amounts,
uint256 min_mint_amount
) external payable;
function add_liquidity(
// sUSD
uint256[4] calldata amounts,
uint256 min_mint_amount
) external payable;
function remove_liquidity_imbalance(
uint256[2] calldata amounts,
uint256 max_burn_amount
) external;
function remove_liquidity(uint256 _amount, uint256[2] calldata amounts)
external;
function remove_liquidity_one_coin(
uint256 _token_amount,
int128 i,
uint256 min_amount
) external;
function exchange(
// CRV-ETH and CVX-ETH
uint256 from,
uint256 to,
uint256 _from_amount,
uint256 _min_to_amount,
bool use_eth
) external;
function exchange(
// sETH
int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount
) external payable returns (uint256);
function balances(uint256) external view returns (uint256);
function price_oracle() external view returns (uint256);
function get_dy(
int128 from,
int128 to,
uint256 _from_amount
) external view returns (uint256);
// EURt
function calc_token_amount(uint256[2] calldata _amounts, bool _is_deposit)
external
view
returns (uint256);
// 3Crv Metapools
function calc_token_amount(
address _pool,
uint256[4] calldata _amounts,
bool _is_deposit
) external view returns (uint256);
// sUSD, Y pool, etc
function calc_token_amount(uint256[4] calldata _amounts, bool _is_deposit)
external
view
returns (uint256);
// 3pool, Iron Bank, etc
function calc_token_amount(uint256[3] calldata _amounts, bool _is_deposit)
external
view
returns (uint256);
function calc_withdraw_one_coin(uint256 amount, int128 i)
external
view
returns (uint256);
}
// Part: IVirtualSynth
interface IVirtualSynth {
// Views
function balanceOfUnderlying(address account)
external
view
returns (uint256);
function rate() external view returns (uint256);
function readyToSettle() external view returns (bool);
function secsLeftInWaitingPeriod() external view returns (uint256);
function settled() external view returns (bool);
function synth() external view returns (ISynth);
// Mutative functions
function settle(address account) external;
}
// Part: OpenZeppelin/[emailย protected]/SafeERC20
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Part: yearn/[emailย protected]/VaultAPI
interface VaultAPI is IERC20 {
function name() external view returns (string calldata);
function symbol() external view returns (string calldata);
function decimals() external view returns (uint256);
function apiVersion() external pure returns (string memory);
function permit(
address owner,
address spender,
uint256 amount,
uint256 expiry,
bytes calldata signature
) external returns (bool);
// NOTE: Vyper produces multiple signatures for a given function with "default" args
function deposit() external returns (uint256);
function deposit(uint256 amount) external returns (uint256);
function deposit(uint256 amount, address recipient) external returns (uint256);
// NOTE: Vyper produces multiple signatures for a given function with "default" args
function withdraw() external returns (uint256);
function withdraw(uint256 maxShares) external returns (uint256);
function withdraw(uint256 maxShares, address recipient) external returns (uint256);
function token() external view returns (address);
function strategies(address _strategy) external view returns (StrategyParams memory);
function pricePerShare() external view returns (uint256);
function totalAssets() external view returns (uint256);
function depositLimit() external view returns (uint256);
function maxAvailableShares() external view returns (uint256);
/**
* View how much the Vault would increase this Strategy's borrow limit,
* based on its present performance (since its last report). Can be used to
* determine expectedReturn in your Strategy.
*/
function creditAvailable() external view returns (uint256);
/**
* View how much the Vault would like to pull back from the Strategy,
* based on its present performance (since its last report). Can be used to
* determine expectedReturn in your Strategy.
*/
function debtOutstanding() external view returns (uint256);
/**
* View how much the Vault expect this Strategy to return at the current
* block, based on its present performance (since its last report). Can be
* used to determine expectedReturn in your Strategy.
*/
function expectedReturn() external view returns (uint256);
/**
* This is the main contact point where the Strategy interacts with the
* Vault. It is critical that this call is handled as intended by the
* Strategy. Therefore, this function will be called by BaseStrategy to
* make sure the integration is correct.
*/
function report(
uint256 _gain,
uint256 _loss,
uint256 _debtPayment
) external returns (uint256);
/**
* This function should only be used in the scenario where the Strategy is
* being retired but no migration of the positions are possible, or in the
* extreme scenario that the Strategy needs to be put into "Emergency Exit"
* mode in order for it to exit as quickly as possible. The latter scenario
* could be for any reason that is considered "critical" that the Strategy
* exits its position as fast as possible, such as a sudden change in
* market conditions leading to losses, or an imminent failure in an
* external dependency.
*/
function revokeStrategy() external;
/**
* View the governance address of the Vault to assert privileged functions
* can only be called by governance. The Strategy serves the Vault, so it
* is subject to governance defined by the Vault.
*/
function governance() external view returns (address);
/**
* View the management address of the Vault to assert privileged functions
* can only be called by management. The Strategy serves the Vault, so it
* is subject to management defined by the Vault.
*/
function management() external view returns (address);
/**
* View the guardian address of the Vault to assert privileged functions
* can only be called by guardian. The Strategy serves the Vault, so it
* is subject to guardian defined by the Vault.
*/
function guardian() external view returns (address);
}
// Part: IExchanger
// https://docs.synthetix.io/contracts/source/interfaces/iexchanger
interface IExchanger {
// Views
function calculateAmountAfterSettlement(
address from,
bytes32 currencyKey,
uint256 amount,
uint256 refunded
) external view returns (uint256 amountAfterSettlement);
function isSynthRateInvalid(bytes32 currencyKey)
external
view
returns (bool);
function maxSecsLeftInWaitingPeriod(address account, bytes32 currencyKey)
external
view
returns (uint256);
function settlementOwing(address account, bytes32 currencyKey)
external
view
returns (
uint256 reclaimAmount,
uint256 rebateAmount,
uint256 numEntries
);
function hasWaitingPeriodOrSettlementOwing(
address account,
bytes32 currencyKey
) external view returns (bool);
function feeRateForExchange(
bytes32 sourceCurrencyKey,
bytes32 destinationCurrencyKey
) external view returns (uint256 exchangeFeeRate);
function getAmountsForExchange(
uint256 sourceAmount,
bytes32 sourceCurrencyKey,
bytes32 destinationCurrencyKey
)
external
view
returns (
uint256 amountReceived,
uint256 fee,
uint256 exchangeFeeRate
);
function priceDeviationThresholdFactor() external view returns (uint256);
function waitingPeriodSecs() external view returns (uint256);
// Mutative functions
function exchange(
address from,
bytes32 sourceCurrencyKey,
uint256 sourceAmount,
bytes32 destinationCurrencyKey,
address destinationAddress
) external returns (uint256 amountReceived);
function exchangeOnBehalf(
address exchangeForAddress,
address from,
bytes32 sourceCurrencyKey,
uint256 sourceAmount,
bytes32 destinationCurrencyKey
) external returns (uint256 amountReceived);
function exchangeWithTracking(
address from,
bytes32 sourceCurrencyKey,
uint256 sourceAmount,
bytes32 destinationCurrencyKey,
address destinationAddress,
address originator,
bytes32 trackingCode
) external returns (uint256 amountReceived);
function exchangeOnBehalfWithTracking(
address exchangeForAddress,
address from,
bytes32 sourceCurrencyKey,
uint256 sourceAmount,
bytes32 destinationCurrencyKey,
address originator,
bytes32 trackingCode
) external returns (uint256 amountReceived);
function exchangeWithVirtual(
address from,
bytes32 sourceCurrencyKey,
uint256 sourceAmount,
bytes32 destinationCurrencyKey,
address destinationAddress,
bytes32 trackingCode
) external returns (uint256 amountReceived, IVirtualSynth vSynth);
function settle(address from, bytes32 currencyKey)
external
returns (
uint256 reclaimed,
uint256 refunded,
uint256 numEntries
);
function setLastExchangeRateForSynth(bytes32 currencyKey, uint256 rate)
external;
function resetLastExchangeRate(bytes32[] calldata currencyKeys) external;
function suspendSynthWithInvalidRate(bytes32 currencyKey) external;
}
// Part: yearn/[emailย protected]/BaseStrategy
/**
* @title Yearn Base Strategy
* @author yearn.finance
* @notice
* BaseStrategy implements all of the required functionality to interoperate
* closely with the Vault contract. This contract should be inherited and the
* abstract methods implemented to adapt the Strategy to the particular needs
* it has to create a return.
*
* Of special interest is the relationship between `harvest()` and
* `vault.report()'. `harvest()` may be called simply because enough time has
* elapsed since the last report, and not because any funds need to be moved
* or positions adjusted. This is critical so that the Vault may maintain an
* accurate picture of the Strategy's performance. See `vault.report()`,
* `harvest()`, and `harvestTrigger()` for further details.
*/
abstract contract BaseStrategy {
using SafeMath for uint256;
using SafeERC20 for IERC20;
string public metadataURI;
// health checks
bool public doHealthCheck;
address public healthCheck;
/**
* @notice
* Used to track which version of `StrategyAPI` this Strategy
* implements.
* @dev The Strategy's version must match the Vault's `API_VERSION`.
* @return A string which holds the current API version of this contract.
*/
function apiVersion() public pure returns (string memory) {
return "0.4.3";
}
/**
* @notice This Strategy's name.
* @dev
* You can use this field to manage the "version" of this Strategy, e.g.
* `StrategySomethingOrOtherV1`. However, "API Version" is managed by
* `apiVersion()` function above.
* @return This Strategy's name.
*/
function name() external view virtual returns (string memory);
/**
* @notice
* The amount (priced in want) of the total assets managed by this strategy should not count
* towards Yearn's TVL calculations.
* @dev
* You can override this field to set it to a non-zero value if some of the assets of this
* Strategy is somehow delegated inside another part of of Yearn's ecosystem e.g. another Vault.
* Note that this value must be strictly less than or equal to the amount provided by
* `estimatedTotalAssets()` below, as the TVL calc will be total assets minus delegated assets.
* Also note that this value is used to determine the total assets under management by this
* strategy, for the purposes of computing the management fee in `Vault`
* @return
* The amount of assets this strategy manages that should not be included in Yearn's Total Value
* Locked (TVL) calculation across it's ecosystem.
*/
function delegatedAssets() external view virtual returns (uint256) {
return 0;
}
VaultAPI public vault;
address public strategist;
address public rewards;
address public keeper;
IERC20 public want;
// So indexers can keep track of this
event Harvested(uint256 profit, uint256 loss, uint256 debtPayment, uint256 debtOutstanding);
event UpdatedStrategist(address newStrategist);
event UpdatedKeeper(address newKeeper);
event UpdatedRewards(address rewards);
event UpdatedMinReportDelay(uint256 delay);
event UpdatedMaxReportDelay(uint256 delay);
event UpdatedProfitFactor(uint256 profitFactor);
event UpdatedDebtThreshold(uint256 debtThreshold);
event EmergencyExitEnabled();
event UpdatedMetadataURI(string metadataURI);
// The minimum number of seconds between harvest calls. See
// `setMinReportDelay()` for more details.
uint256 public minReportDelay;
// The maximum number of seconds between harvest calls. See
// `setMaxReportDelay()` for more details.
uint256 public maxReportDelay;
// The minimum multiple that `callCost` must be above the credit/profit to
// be "justifiable". See `setProfitFactor()` for more details.
uint256 public profitFactor;
// Use this to adjust the threshold at which running a debt causes a
// harvest trigger. See `setDebtThreshold()` for more details.
uint256 public debtThreshold;
// See note on `setEmergencyExit()`.
bool public emergencyExit;
// modifiers
modifier onlyAuthorized() {
require(msg.sender == strategist || msg.sender == governance(), "!authorized");
_;
}
modifier onlyEmergencyAuthorized() {
require(
msg.sender == strategist || msg.sender == governance() || msg.sender == vault.guardian() || msg.sender == vault.management(),
"!authorized"
);
_;
}
modifier onlyStrategist() {
require(msg.sender == strategist, "!strategist");
_;
}
modifier onlyGovernance() {
require(msg.sender == governance(), "!authorized");
_;
}
modifier onlyKeepers() {
require(
msg.sender == keeper ||
msg.sender == strategist ||
msg.sender == governance() ||
msg.sender == vault.guardian() ||
msg.sender == vault.management(),
"!authorized"
);
_;
}
modifier onlyVaultManagers() {
require(msg.sender == vault.management() || msg.sender == governance(), "!authorized");
_;
}
constructor(address _vault) public {
_initialize(_vault, msg.sender, msg.sender, msg.sender);
}
/**
* @notice
* Initializes the Strategy, this is called only once, when the
* contract is deployed.
* @dev `_vault` should implement `VaultAPI`.
* @param _vault The address of the Vault responsible for this Strategy.
* @param _strategist The address to assign as `strategist`.
* The strategist is able to change the reward address
* @param _rewards The address to use for pulling rewards.
* @param _keeper The adddress of the _keeper. _keeper
* can harvest and tend a strategy.
*/
function _initialize(
address _vault,
address _strategist,
address _rewards,
address _keeper
) internal {
require(address(want) == address(0), "Strategy already initialized");
vault = VaultAPI(_vault);
want = IERC20(vault.token());
want.safeApprove(_vault, uint256(-1)); // Give Vault unlimited access (might save gas)
strategist = _strategist;
rewards = _rewards;
keeper = _keeper;
// initialize variables
minReportDelay = 0;
maxReportDelay = 86400;
profitFactor = 100;
debtThreshold = 0;
vault.approve(rewards, uint256(-1)); // Allow rewards to be pulled
}
function setHealthCheck(address _healthCheck) external onlyVaultManagers {
healthCheck = _healthCheck;
}
function setDoHealthCheck(bool _doHealthCheck) external onlyVaultManagers {
doHealthCheck = _doHealthCheck;
}
/**
* @notice
* Used to change `strategist`.
*
* This may only be called by governance or the existing strategist.
* @param _strategist The new address to assign as `strategist`.
*/
function setStrategist(address _strategist) external onlyAuthorized {
require(_strategist != address(0));
strategist = _strategist;
emit UpdatedStrategist(_strategist);
}
/**
* @notice
* Used to change `keeper`.
*
* `keeper` is the only address that may call `tend()` or `harvest()`,
* other than `governance()` or `strategist`. However, unlike
* `governance()` or `strategist`, `keeper` may *only* call `tend()`
* and `harvest()`, and no other authorized functions, following the
* principle of least privilege.
*
* This may only be called by governance or the strategist.
* @param _keeper The new address to assign as `keeper`.
*/
function setKeeper(address _keeper) external onlyAuthorized {
require(_keeper != address(0));
keeper = _keeper;
emit UpdatedKeeper(_keeper);
}
/**
* @notice
* Used to change `rewards`. EOA or smart contract which has the permission
* to pull rewards from the vault.
*
* This may only be called by the strategist.
* @param _rewards The address to use for pulling rewards.
*/
function setRewards(address _rewards) external onlyStrategist {
require(_rewards != address(0));
vault.approve(rewards, 0);
rewards = _rewards;
vault.approve(rewards, uint256(-1));
emit UpdatedRewards(_rewards);
}
/**
* @notice
* Used to change `minReportDelay`. `minReportDelay` is the minimum number
* of blocks that should pass for `harvest()` to be called.
*
* For external keepers (such as the Keep3r network), this is the minimum
* time between jobs to wait. (see `harvestTrigger()`
* for more details.)
*
* This may only be called by governance or the strategist.
* @param _delay The minimum number of seconds to wait between harvests.
*/
function setMinReportDelay(uint256 _delay) external onlyAuthorized {
minReportDelay = _delay;
emit UpdatedMinReportDelay(_delay);
}
/**
* @notice
* Used to change `maxReportDelay`. `maxReportDelay` is the maximum number
* of blocks that should pass for `harvest()` to be called.
*
* For external keepers (such as the Keep3r network), this is the maximum
* time between jobs to wait. (see `harvestTrigger()`
* for more details.)
*
* This may only be called by governance or the strategist.
* @param _delay The maximum number of seconds to wait between harvests.
*/
function setMaxReportDelay(uint256 _delay) external onlyAuthorized {
maxReportDelay = _delay;
emit UpdatedMaxReportDelay(_delay);
}
/**
* @notice
* Used to change `profitFactor`. `profitFactor` is used to determine
* if it's worthwhile to harvest, given gas costs. (See `harvestTrigger()`
* for more details.)
*
* This may only be called by governance or the strategist.
* @param _profitFactor A ratio to multiply anticipated
* `harvest()` gas cost against.
*/
function setProfitFactor(uint256 _profitFactor) external onlyAuthorized {
profitFactor = _profitFactor;
emit UpdatedProfitFactor(_profitFactor);
}
/**
* @notice
* Sets how far the Strategy can go into loss without a harvest and report
* being required.
*
* By default this is 0, meaning any losses would cause a harvest which
* will subsequently report the loss to the Vault for tracking. (See
* `harvestTrigger()` for more details.)
*
* This may only be called by governance or the strategist.
* @param _debtThreshold How big of a loss this Strategy may carry without
* being required to report to the Vault.
*/
function setDebtThreshold(uint256 _debtThreshold) external onlyAuthorized {
debtThreshold = _debtThreshold;
emit UpdatedDebtThreshold(_debtThreshold);
}
/**
* @notice
* Used to change `metadataURI`. `metadataURI` is used to store the URI
* of the file describing the strategy.
*
* This may only be called by governance or the strategist.
* @param _metadataURI The URI that describe the strategy.
*/
function setMetadataURI(string calldata _metadataURI) external onlyAuthorized {
metadataURI = _metadataURI;
emit UpdatedMetadataURI(_metadataURI);
}
/**
* Resolve governance address from Vault contract, used to make assertions
* on protected functions in the Strategy.
*/
function governance() internal view returns (address) {
return vault.governance();
}
/**
* @notice
* Provide an accurate conversion from `_amtInWei` (denominated in wei)
* to `want` (using the native decimal characteristics of `want`).
* @dev
* Care must be taken when working with decimals to assure that the conversion
* is compatible. As an example:
*
* given 1e17 wei (0.1 ETH) as input, and want is USDC (6 decimals),
* with USDC/ETH = 1800, this should give back 1800000000 (180 USDC)
*
* @param _amtInWei The amount (in wei/1e-18 ETH) to convert to `want`
* @return The amount in `want` of `_amtInEth` converted to `want`
**/
function ethToWant(uint256 _amtInWei) public view virtual returns (uint256);
/**
* @notice
* Provide an accurate estimate for the total amount of assets
* (principle + return) that this Strategy is currently managing,
* denominated in terms of `want` tokens.
*
* This total should be "realizable" e.g. the total value that could
* *actually* be obtained from this Strategy if it were to divest its
* entire position based on current on-chain conditions.
* @dev
* Care must be taken in using this function, since it relies on external
* systems, which could be manipulated by the attacker to give an inflated
* (or reduced) value produced by this function, based on current on-chain
* conditions (e.g. this function is possible to influence through
* flashloan attacks, oracle manipulations, or other DeFi attack
* mechanisms).
*
* It is up to governance to use this function to correctly order this
* Strategy relative to its peers in the withdrawal queue to minimize
* losses for the Vault based on sudden withdrawals. This value should be
* higher than the total debt of the Strategy and higher than its expected
* value to be "safe".
* @return The estimated total assets in this Strategy.
*/
function estimatedTotalAssets() public view virtual returns (uint256);
/*
* @notice
* Provide an indication of whether this strategy is currently "active"
* in that it is managing an active position, or will manage a position in
* the future. This should correlate to `harvest()` activity, so that Harvest
* events can be tracked externally by indexing agents.
* @return True if the strategy is actively managing a position.
*/
function isActive() public view returns (bool) {
return vault.strategies(address(this)).debtRatio > 0 || estimatedTotalAssets() > 0;
}
/**
* Perform any Strategy unwinding or other calls necessary to capture the
* "free return" this Strategy has generated since the last time its core
* position(s) were adjusted. Examples include unwrapping extra rewards.
* This call is only used during "normal operation" of a Strategy, and
* should be optimized to minimize losses as much as possible.
*
* This method returns any realized profits and/or realized losses
* incurred, and should return the total amounts of profits/losses/debt
* payments (in `want` tokens) for the Vault's accounting (e.g.
* `want.balanceOf(this) >= _debtPayment + _profit`).
*
* `_debtOutstanding` will be 0 if the Strategy is not past the configured
* debt limit, otherwise its value will be how far past the debt limit
* the Strategy is. The Strategy's debt limit is configured in the Vault.
*
* NOTE: `_debtPayment` should be less than or equal to `_debtOutstanding`.
* It is okay for it to be less than `_debtOutstanding`, as that
* should only used as a guide for how much is left to pay back.
* Payments should be made to minimize loss from slippage, debt,
* withdrawal fees, etc.
*
* See `vault.debtOutstanding()`.
*/
function prepareReturn(uint256 _debtOutstanding)
internal
virtual
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
);
/**
* Perform any adjustments to the core position(s) of this Strategy given
* what change the Vault made in the "investable capital" available to the
* Strategy. Note that all "free capital" in the Strategy after the report
* was made is available for reinvestment. Also note that this number
* could be 0, and you should handle that scenario accordingly.
*
* See comments regarding `_debtOutstanding` on `prepareReturn()`.
*/
function adjustPosition(uint256 _debtOutstanding) internal virtual;
/**
* Liquidate up to `_amountNeeded` of `want` of this strategy's positions,
* irregardless of slippage. Any excess will be re-invested with `adjustPosition()`.
* This function should return the amount of `want` tokens made available by the
* liquidation. If there is a difference between them, `_loss` indicates whether the
* difference is due to a realized loss, or if there is some other sitution at play
* (e.g. locked funds) where the amount made available is less than what is needed.
*
* NOTE: The invariant `_liquidatedAmount + _loss <= _amountNeeded` should always be maintained
*/
function liquidatePosition(uint256 _amountNeeded) internal virtual returns (uint256 _liquidatedAmount, uint256 _loss);
/**
* Liquidate everything and returns the amount that got freed.
* This function is used during emergency exit instead of `prepareReturn()` to
* liquidate all of the Strategy's positions back to the Vault.
*/
function liquidateAllPositions() internal virtual returns (uint256 _amountFreed);
/**
* @notice
* Provide a signal to the keeper that `tend()` should be called. The
* keeper will provide the estimated gas cost that they would pay to call
* `tend()`, and this function should use that estimate to make a
* determination if calling it is "worth it" for the keeper. This is not
* the only consideration into issuing this trigger, for example if the
* position would be negatively affected if `tend()` is not called
* shortly, then this can return `true` even if the keeper might be
* "at a loss" (keepers are always reimbursed by Yearn).
* @dev
* `callCostInWei` must be priced in terms of `wei` (1e-18 ETH).
*
* This call and `harvestTrigger()` should never return `true` at the same
* time.
* @param callCostInWei The keeper's estimated gas cost to call `tend()` (in wei).
* @return `true` if `tend()` should be called, `false` otherwise.
*/
function tendTrigger(uint256 callCostInWei) public view virtual returns (bool) {
// We usually don't need tend, but if there are positions that need
// active maintainence, overriding this function is how you would
// signal for that.
// If your implementation uses the cost of the call in want, you can
// use uint256 callCost = ethToWant(callCostInWei);
return false;
}
/**
* @notice
* Adjust the Strategy's position. The purpose of tending isn't to
* realize gains, but to maximize yield by reinvesting any returns.
*
* See comments on `adjustPosition()`.
*
* This may only be called by governance, the strategist, or the keeper.
*/
function tend() external onlyKeepers {
// Don't take profits with this call, but adjust for better gains
adjustPosition(vault.debtOutstanding());
}
/**
* @notice
* Provide a signal to the keeper that `harvest()` should be called. The
* keeper will provide the estimated gas cost that they would pay to call
* `harvest()`, and this function should use that estimate to make a
* determination if calling it is "worth it" for the keeper. This is not
* the only consideration into issuing this trigger, for example if the
* position would be negatively affected if `harvest()` is not called
* shortly, then this can return `true` even if the keeper might be "at a
* loss" (keepers are always reimbursed by Yearn).
* @dev
* `callCostInWei` must be priced in terms of `wei` (1e-18 ETH).
*
* This call and `tendTrigger` should never return `true` at the
* same time.
*
* See `min/maxReportDelay`, `profitFactor`, `debtThreshold` to adjust the
* strategist-controlled parameters that will influence whether this call
* returns `true` or not. These parameters will be used in conjunction
* with the parameters reported to the Vault (see `params`) to determine
* if calling `harvest()` is merited.
*
* It is expected that an external system will check `harvestTrigger()`.
* This could be a script run off a desktop or cloud bot (e.g.
* https://github.com/iearn-finance/yearn-vaults/blob/main/scripts/keep.py),
* or via an integration with the Keep3r network (e.g.
* https://github.com/Macarse/GenericKeep3rV2/blob/master/contracts/keep3r/GenericKeep3rV2.sol).
* @param callCostInWei The keeper's estimated gas cost to call `harvest()` (in wei).
* @return `true` if `harvest()` should be called, `false` otherwise.
*/
function harvestTrigger(uint256 callCostInWei) public view virtual returns (bool) {
uint256 callCost = ethToWant(callCostInWei);
StrategyParams memory params = vault.strategies(address(this));
// Should not trigger if Strategy is not activated
if (params.activation == 0) return false;
// Should not trigger if we haven't waited long enough since previous harvest
if (block.timestamp.sub(params.lastReport) < minReportDelay) return false;
// Should trigger if hasn't been called in a while
if (block.timestamp.sub(params.lastReport) >= maxReportDelay) return true;
// If some amount is owed, pay it back
// NOTE: Since debt is based on deposits, it makes sense to guard against large
// changes to the value from triggering a harvest directly through user
// behavior. This should ensure reasonable resistance to manipulation
// from user-initiated withdrawals as the outstanding debt fluctuates.
uint256 outstanding = vault.debtOutstanding();
if (outstanding > debtThreshold) return true;
// Check for profits and losses
uint256 total = estimatedTotalAssets();
// Trigger if we have a loss to report
if (total.add(debtThreshold) < params.totalDebt) return true;
uint256 profit = 0;
if (total > params.totalDebt) profit = total.sub(params.totalDebt); // We've earned a profit!
// Otherwise, only trigger if it "makes sense" economically (gas cost
// is <N% of value moved)
uint256 credit = vault.creditAvailable();
return (profitFactor.mul(callCost) < credit.add(profit));
}
/**
* @notice
* Harvests the Strategy, recognizing any profits or losses and adjusting
* the Strategy's position.
*
* In the rare case the Strategy is in emergency shutdown, this will exit
* the Strategy's position.
*
* This may only be called by governance, the strategist, or the keeper.
* @dev
* When `harvest()` is called, the Strategy reports to the Vault (via
* `vault.report()`), so in some cases `harvest()` must be called in order
* to take in profits, to borrow newly available funds from the Vault, or
* otherwise adjust its position. In other cases `harvest()` must be
* called to report to the Vault on the Strategy's position, especially if
* any losses have occurred.
*/
function harvest() external onlyKeepers {
uint256 profit = 0;
uint256 loss = 0;
uint256 debtOutstanding = vault.debtOutstanding();
uint256 debtPayment = 0;
if (emergencyExit) {
// Free up as much capital as possible
uint256 amountFreed = liquidateAllPositions();
if (amountFreed < debtOutstanding) {
loss = debtOutstanding.sub(amountFreed);
} else if (amountFreed > debtOutstanding) {
profit = amountFreed.sub(debtOutstanding);
}
debtPayment = debtOutstanding.sub(loss);
} else {
// Free up returns for Vault to pull
(profit, loss, debtPayment) = prepareReturn(debtOutstanding);
}
// Allow Vault to take up to the "harvested" balance of this contract,
// which is the amount it has earned since the last time it reported to
// the Vault.
uint256 totalDebt = vault.strategies(address(this)).totalDebt;
debtOutstanding = vault.report(profit, loss, debtPayment);
// Check if free returns are left, and re-invest them
adjustPosition(debtOutstanding);
// call healthCheck contract
if (doHealthCheck && healthCheck != address(0)) {
require(HealthCheck(healthCheck).check(profit, loss, debtPayment, debtOutstanding, totalDebt), "!healthcheck");
} else {
doHealthCheck = true;
}
emit Harvested(profit, loss, debtPayment, debtOutstanding);
}
/**
* @notice
* Withdraws `_amountNeeded` to `vault`.
*
* This may only be called by the Vault.
* @param _amountNeeded How much `want` to withdraw.
* @return _loss Any realized losses
*/
function withdraw(uint256 _amountNeeded) external returns (uint256 _loss) {
require(msg.sender == address(vault), "!vault");
// Liquidate as much as possible to `want`, up to `_amountNeeded`
uint256 amountFreed;
(amountFreed, _loss) = liquidatePosition(_amountNeeded);
// Send it directly back (NOTE: Using `msg.sender` saves some gas here)
want.safeTransfer(msg.sender, amountFreed);
// NOTE: Reinvest anything leftover on next `tend`/`harvest`
}
/**
* Do anything necessary to prepare this Strategy for migration, such as
* transferring any reserve or LP tokens, CDPs, or other tokens or stores of
* value.
*/
function prepareMigration(address _newStrategy) internal virtual;
/**
* @notice
* Transfers all `want` from this Strategy to `_newStrategy`.
*
* This may only be called by the Vault.
* @dev
* The new Strategy's Vault must be the same as this Strategy's Vault.
* The migration process should be carefully performed to make sure all
* the assets are migrated to the new address, which should have never
* interacted with the vault before.
* @param _newStrategy The Strategy to migrate to.
*/
function migrate(address _newStrategy) external {
require(msg.sender == address(vault));
require(BaseStrategy(_newStrategy).vault() == vault);
prepareMigration(_newStrategy);
want.safeTransfer(_newStrategy, want.balanceOf(address(this)));
}
/**
* @notice
* Activates emergency exit. Once activated, the Strategy will exit its
* position upon the next harvest, depositing all funds into the Vault as
* quickly as is reasonable given on-chain conditions.
*
* This may only be called by governance or the strategist.
* @dev
* See `vault.setEmergencyShutdown()` and `harvest()` for further details.
*/
function setEmergencyExit() external onlyEmergencyAuthorized {
emergencyExit = true;
vault.revokeStrategy();
emit EmergencyExitEnabled();
}
/**
* Override this to add all tokens/tokenized positions this contract
* manages on a *persistent* basis (e.g. not just for swapping back to
* want ephemerally).
*
* NOTE: Do *not* include `want`, already included in `sweep` below.
*
* Example:
* ```
* function protectedTokens() internal override view returns (address[] memory) {
* address[] memory protected = new address[](3);
* protected[0] = tokenA;
* protected[1] = tokenB;
* protected[2] = tokenC;
* return protected;
* }
* ```
*/
function protectedTokens() internal view virtual returns (address[] memory);
/**
* @notice
* Removes tokens from this Strategy that are not the type of tokens
* managed by this Strategy. This may be used in case of accidentally
* sending the wrong kind of token to this Strategy.
*
* Tokens will be sent to `governance()`.
*
* This will fail if an attempt is made to sweep `want`, or any tokens
* that are protected by this Strategy.
*
* This may only be called by governance.
* @dev
* Implement `protectedTokens()` to specify any additional tokens that
* should be protected from sweeping in addition to `want`.
* @param _token The token to transfer out of this vault.
*/
function sweep(address _token) external onlyGovernance {
require(_token != address(want), "!want");
require(_token != address(vault), "!shares");
address[] memory _protectedTokens = protectedTokens();
for (uint256 i; i < _protectedTokens.length; i++) require(_token != _protectedTokens[i], "!protected");
IERC20(_token).safeTransfer(governance(), IERC20(_token).balanceOf(address(this)));
}
}
// Part: StrategyConvexBase
abstract contract StrategyConvexBase is BaseStrategy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
/* ========== STATE VARIABLES ========== */
// these should stay the same across different wants.
// convex stuff
address internal constant depositContract =
0xF403C135812408BFbE8713b5A23a04b3D48AAE31; // this is the deposit contract that all pools use, aka booster
IConvexRewards public rewardsContract; // This is unique to each curve pool
uint256 public pid; // this is unique to each pool
// keepCRV stuff
uint256 public keepCRV; // the percentage of CRV we re-lock for boost (in basis points)
address internal constant voter =
0xF147b8125d2ef93FB6965Db97D6746952a133934; // Yearn's veCRV voter, we send some extra CRV here
uint256 internal constant FEE_DENOMINATOR = 10000; // this means all of our fee values are in bips
// Swap stuff
ICurveFi public curve; // Curve Pool, need this for depositing into our curve pool
IERC20 internal constant crv =
IERC20(0xD533a949740bb3306d119CC777fa900bA034cd52);
IERC20 internal constant convexToken =
IERC20(0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B);
IERC20 internal constant weth =
IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
// keeper stuff
uint256 public harvestProfitMin; // minimum size in USDT that we want to harvest
uint256 public harvestProfitMax; // maximum size in USDT that we want to harvest
uint256 public creditThreshold; // amount of credit in underlying tokens that will automatically trigger a harvest
bool internal forceHarvestTriggerOnce; // only set this to true when we want to trigger our keepers to harvest for us
bool internal forceTendTriggerOnce; // only set this to true when we want to trigger our keepers to tend for us
string internal stratName; // we use this to be able to adjust our strategy's name
// convex-specific variables
bool public claimRewards; // boolean if we should always claim rewards when withdrawing, usually withdrawAndUnwrap (generally this should be false)
/* ========== CONSTRUCTOR ========== */
constructor(address _vault) public BaseStrategy(_vault) {}
/* ========== VIEWS ========== */
function name() external view override returns (string memory) {
return stratName;
}
function stakedBalance() public view returns (uint256) {
// how much want we have staked in Convex
return IConvexRewards(rewardsContract).balanceOf(address(this));
}
function balanceOfWant() public view returns (uint256) {
// balance of want sitting in our strategy
return want.balanceOf(address(this));
}
function claimableBalance() public view returns (uint256) {
// how much CRV we can claim from the staking contract
return IConvexRewards(rewardsContract).earned(address(this));
}
function estimatedTotalAssets() public view override returns (uint256) {
return balanceOfWant().add(stakedBalance());
}
/* ========== CONSTANT FUNCTIONS ========== */
// these should stay the same across different wants.
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
uint256 _wantBal = balanceOfWant();
if (_amountNeeded > _wantBal) {
uint256 _stakedBal = stakedBalance();
if (_stakedBal > 0) {
IConvexRewards(rewardsContract).withdrawAndUnwrap(
Math.min(_stakedBal, _amountNeeded.sub(_wantBal)),
claimRewards
);
}
uint256 _withdrawnBal = balanceOfWant();
_liquidatedAmount = Math.min(_amountNeeded, _withdrawnBal);
_loss = _amountNeeded.sub(_liquidatedAmount);
} else {
// we have enough balance to cover the liquidation available
return (_amountNeeded, 0);
}
}
// fire sale, get rid of it all!
function liquidateAllPositions() internal override returns (uint256) {
uint256 _stakedBal = stakedBalance();
if (_stakedBal > 0) {
// don't bother withdrawing zero
IConvexRewards(rewardsContract).withdrawAndUnwrap(
_stakedBal,
claimRewards
);
}
return balanceOfWant();
}
// in case we need to exit into the convex deposit token, this will allow us to do that
// make sure to check claimRewards before this step if needed
// plan to have gov sweep convex deposit tokens from strategy after this
function withdrawToConvexDepositTokens() external onlyEmergencyAuthorized {
uint256 _stakedBal = stakedBalance();
if (_stakedBal > 0) {
IConvexRewards(rewardsContract).withdraw(_stakedBal, claimRewards);
}
}
// we don't want for these tokens to be swept out. We allow gov to sweep out cvx vault tokens; we would only be holding these if things were really, really rekt.
function protectedTokens()
internal
view
override
returns (address[] memory)
{}
/* ========== SETTERS ========== */
// These functions are useful for setting parameters of the strategy that may need to be adjusted.
// Set the amount of CRV to be locked in Yearn's veCRV voter from each harvest. Default is 10%.
function setKeepCRV(uint256 _keepCRV) external onlyGovernance {
require(_keepCRV <= 10_000);
keepCRV = _keepCRV;
}
// We usually don't need to claim rewards on withdrawals, but might change our mind for migrations etc
function setClaimRewards(bool _claimRewards)
external
onlyEmergencyAuthorized
{
claimRewards = _claimRewards;
}
// This allows us to manually harvest or tend with our keeper as needed
function setForceTriggerOnce(
bool _forceTendTriggerOnce,
bool _forceHarvestTriggerOnce
) external onlyEmergencyAuthorized {
forceTendTriggerOnce = _forceTendTriggerOnce;
forceHarvestTriggerOnce = _forceHarvestTriggerOnce;
}
}
// File: StrategyConvexFixedForexClonable.sol
contract StrategyConvexFixedForexClonable is StrategyConvexBase {
/* ========== STATE VARIABLES ========== */
// these will likely change across different wants.
// synthetix stuff
IReadProxy public sTokenProxy; // this is the proxy for our synthetix token
IERC20 internal constant sethProxy =
IERC20(0x5e74C9036fb86BD7eCdcb084a0673EFc32eA31cb); // this is the proxy for sETH
IReadProxy internal constant readProxy =
IReadProxy(0x4E3b31eB0E5CB73641EE1E65E7dCEFe520bA3ef2);
ISystemStatus internal constant systemStatus =
ISystemStatus(0x1c86B3CDF2a60Ae3a574f7f71d44E2C50BDdB87E); // this is how we check if our market is closed
bytes32 public synthCurrencyKey;
bytes32 internal constant sethCurrencyKey = "sETH";
bytes32 internal constant TRACKING_CODE = "YEARN"; // this is our referral code for SNX volume incentives
bytes32 internal constant CONTRACT_SYNTHETIX = "Synthetix";
bytes32 internal constant CONTRACT_EXCHANGER = "Exchanger";
// swap stuff
address internal constant uniswapv3 =
address(0xE592427A0AEce92De3Edee1F18E0157C05861564);
bool internal harvestNow; // this tells us if we're currently harvesting or tending
uint256 public lastTendTime; // this is the timestamp that our last tend was called
bool public checkEarmark; // this determines if we should check if we need to earmark rewards before harvesting
// use Curve to sell our CVX and CRV rewards to WETH
ICurveFi internal constant crveth =
ICurveFi(0x8301AE4fc9c624d1D396cbDAa1ed877821D7C511); // use curve's new CRV-ETH crypto pool to sell our CRV
ICurveFi internal constant cvxeth =
ICurveFi(0xB576491F1E6e5E62f1d8F26062Ee822B40B0E0d4); // use curve's new CVX-ETH crypto pool to sell our CVX
ICurveFi internal constant setheth =
ICurveFi(0xc5424B857f758E906013F3555Dad202e4bdB4567); // use curve's sETH-ETH crypto pool to swap our ETH to sETH
// kp3r and rkp3r
IERC20 internal constant rkpr =
IERC20(0xEdB67Ee1B171c4eC66E6c10EC43EDBbA20FaE8e9);
address internal constant kpr = 0x1cEB5cB57C4D4E2b2433641b95Dd330A33185A44;
bool public doSellRkpr; // bool for selling our rKP3R rewards on uniswap v3
// check for cloning
bool internal isOriginal = true;
/* ========== CONSTRUCTOR ========== */
constructor(
address _vault,
uint256 _pid,
address _curvePool,
address _sTokenProxy,
string memory _name
) public StrategyConvexBase(_vault) {
_initializeStrat(_pid, _curvePool, _sTokenProxy, _name);
}
/* ========== CLONING ========== */
event Cloned(address indexed clone);
// we use this to clone our original strategy to other vaults
function cloneConvexibFF(
address _vault,
address _strategist,
address _rewards,
address _keeper,
uint256 _pid,
address _curvePool,
address _sTokenProxy,
string memory _name
) external returns (address payable newStrategy) {
require(isOriginal);
// Copied from https://github.com/optionality/clone-factory/blob/master/contracts/CloneFactory.sol
bytes20 addressBytes = bytes20(address(this));
assembly {
// EIP-1167 bytecode
let clone_code := mload(0x40)
mstore(
clone_code,
0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
)
mstore(add(clone_code, 0x14), addressBytes)
mstore(
add(clone_code, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
newStrategy := create(0, clone_code, 0x37)
}
StrategyConvexFixedForexClonable(newStrategy).initialize(
_vault,
_strategist,
_rewards,
_keeper,
_pid,
_curvePool,
_sTokenProxy,
_name
);
emit Cloned(newStrategy);
}
// this will only be called by the clone function above
function initialize(
address _vault,
address _strategist,
address _rewards,
address _keeper,
uint256 _pid,
address _curvePool,
address _sTokenProxy,
string memory _name
) public {
_initialize(_vault, _strategist, _rewards, _keeper);
_initializeStrat(_pid, _curvePool, _sTokenProxy, _name);
}
// this is called by our original strategy, as well as any clones
function _initializeStrat(
uint256 _pid,
address _curvePool,
address _sTokenProxy,
string memory _name
) internal {
// make sure that we haven't initialized this before
require(address(curve) == address(0)); // already initialized.
// You can set these parameters on deployment to whatever you want
maxReportDelay = 21 days; // 21 days in seconds, if we hit this then harvestTrigger = True
healthCheck = 0xDDCea799fF1699e98EDF118e0629A974Df7DF012; // health.ychad.eth
// these are our standard approvals for swaps. want = Curve LP token
want.approve(address(depositContract), type(uint256).max);
convexToken.approve(address(cvxeth), type(uint256).max);
crv.approve(address(crveth), type(uint256).max);
weth.approve(uniswapv3, type(uint256).max);
rkpr.approve(uniswapv3, type(uint256).max);
// set our keepCRV
keepCRV = 1000;
// this is the pool specific to this vault, used for depositing
curve = ICurveFi(_curvePool);
// setup our rewards contract
pid = _pid; // this is the pool ID on convex, we use this to determine what the reweardsContract address is
(address lptoken, , , address _rewardsContract, , ) =
IConvexDeposit(depositContract).poolInfo(_pid);
// set up our rewardsContract
rewardsContract = IConvexRewards(_rewardsContract);
// check that our LP token based on our pid matches our want
require(address(lptoken) == address(want));
// set our strategy's name
stratName = _name;
// set our token to swap for and deposit with
sTokenProxy = IReadProxy(_sTokenProxy);
// these are our approvals and path specific to this contract
sTokenProxy.approve(address(curve), type(uint256).max);
// set our synth currency key
synthCurrencyKey = ISynth(IReadProxy(_sTokenProxy).target())
.currencyKey();
// set our last tend time to the deployment block
lastTendTime = block.timestamp;
}
/* ========== VARIABLE FUNCTIONS ========== */
// these will likely change across different wants.
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
// turn on our toggle for harvests
harvestNow = true;
// deposit our sToken to Curve if we have any and if our trade has finalized
uint256 _sTokenProxyBalance = sTokenProxy.balanceOf(address(this));
if (_sTokenProxyBalance > 0 && checkWaitingPeriod()) {
curve.add_liquidity([0, _sTokenProxyBalance], 0);
}
// debtOustanding will only be > 0 in the event of revoking or if we need to rebalance from a withdrawal or lowering the debtRatio
if (_debtOutstanding > 0) {
uint256 _stakedBal = stakedBalance();
if (_stakedBal > 0) {
IConvexRewards(rewardsContract).withdrawAndUnwrap(
Math.min(_stakedBal, _debtOutstanding),
claimRewards
);
}
uint256 _withdrawnBal = balanceOfWant();
_debtPayment = Math.min(_debtOutstanding, _withdrawnBal);
}
// serious loss should never happen, but if it does (for instance, if Curve is hacked), let's record it accurately
uint256 assets = estimatedTotalAssets();
uint256 debt = vault.strategies(address(this)).totalDebt;
// if assets are greater than debt, things are working great!
if (assets > debt) {
_profit = assets.sub(debt);
uint256 _wantBal = balanceOfWant();
if (_profit.add(_debtPayment) > _wantBal) {
// this should only be hit following donations to strategy
liquidateAllPositions();
}
}
// if assets are less than debt, we are in trouble
else {
_loss = debt.sub(assets);
}
// we're done harvesting, so reset our trigger if we used it
forceHarvestTriggerOnce = false;
}
function adjustPosition(uint256 _debtOutstanding) internal override {
if (emergencyExit) {
return;
}
if (harvestNow) {
// Send all of our Curve pool tokens to be deposited
uint256 _toInvest = balanceOfWant();
// deposit into convex and stake immediately but only if we have something to invest
if (_toInvest > 0) {
IConvexDeposit(depositContract).deposit(pid, _toInvest, true);
}
// we're done with our harvest, so we turn our toggle back to false
harvestNow = false;
} else {
// this is our tend call
claimAndSell();
// update our variable for tracking last tend time
lastTendTime = block.timestamp;
// we're done harvesting, so reset our trigger if we used it
forceTendTriggerOnce = false;
}
}
// migrate our want token to a new strategy if needed, make sure to check claimRewards first
// also send over any CRV or CVX that is claimed; for migrations we definitely want to claim
function prepareMigration(address _newStrategy) internal override {
uint256 _stakedBal = stakedBalance();
if (_stakedBal > 0) {
IConvexRewards(rewardsContract).withdrawAndUnwrap(
_stakedBal,
claimRewards
);
}
crv.safeTransfer(_newStrategy, crv.balanceOf(address(this)));
convexToken.safeTransfer(
_newStrategy,
convexToken.balanceOf(address(this))
);
sethProxy.safeTransfer(
_newStrategy,
convexToken.balanceOf(address(this))
);
}
// Sells our CRV and CVX to ETH on Curve
function _sellCrvAndCvx(uint256 _crvAmount, uint256 _convexAmount)
internal
{
if (_convexAmount > 0) {
cvxeth.exchange(1, 0, _convexAmount, 0, true);
}
if (_crvAmount > 0) {
crveth.exchange(1, 0, _crvAmount, 0, true);
}
}
// Sells our rKP3R rewards for more want on uniV3
function _sellRkpr(uint256 _amount) internal {
IUniV3(uniswapv3).exactInput(
IUniV3.ExactInputParams(
abi.encodePacked(
address(rkpr),
uint24(500),
kpr,
uint24(10000),
address(weth)
),
address(this),
block.timestamp,
_amount,
uint256(1)
)
);
uint256 wethBalance = weth.balanceOf(address(this));
IWeth(address(weth)).withdraw(wethBalance);
}
/* ========== KEEP3RS ========== */
function harvestTrigger(uint256 callCostinEth)
public
view
override
returns (bool)
{
// Should not trigger if strategy is not active (no assets and no debtRatio). This means we don't need to adjust keeper job.
if (!isActive()) {
return false;
}
// check if the 5-minute lock has elapsed yet
if (!checkWaitingPeriod()) {
return false;
}
// check if the base fee gas price is higher than we allow. if it is, block harvests.
if (!isBaseFeeAcceptable()) {
return false;
}
// trigger if we want to manually harvest, but only if our gas price is acceptable
if (forceHarvestTriggerOnce) {
if (forceTendTriggerOnce) {
return false;
} else {
return true;
}
}
// harvest our profit if we have tended since our last harvest
StrategyParams memory params = vault.strategies(address(this));
if (lastTendTime > params.lastReport) {
return true;
}
// harvest our credit if it's above our threshold
if (vault.creditAvailable() > creditThreshold) {
return true;
}
// otherwise, we don't harvest
return false;
}
function tendTrigger(uint256 callCostinEth)
public
view
override
returns (bool)
{
// Should not trigger if strategy is not active (no assets and no debtRatio). This means we don't need to adjust keeper job.
if (!isActive()) {
return false;
}
// only check if we need to earmark on vaults we know are problematic
if (checkEarmark) {
// don't harvest if we need to earmark convex rewards
if (needsEarmarkReward()) {
return false;
}
}
// Should not tend if forex markets are closed.
if (isMarketClosed()) {
return false;
}
// harvest if we have a profit to claim at our upper limit without considering gas price
uint256 claimableProfit = claimableProfitInUsdt();
if (claimableProfit > harvestProfitMax) {
return true;
}
// check if the base fee gas price is higher than we allow. if it is, block harvests.
if (!isBaseFeeAcceptable()) {
return false;
}
// trigger if we want to manually harvest, but only if our gas price is acceptable
if (forceTendTriggerOnce) {
return true;
}
// harvest if we have a sufficient profit to claim, but only if our gas price is acceptable
if (claimableProfit > harvestProfitMin) {
return true;
}
// Should trigger if hasn't been called in a while. Running this based on harvest even though this is a tend call since a harvest should run ~5 mins after every tend.
if (block.timestamp.sub(lastTendTime) >= maxReportDelay) return true;
}
// we will need to add rewards token here if we have them
function claimableProfitInUsdt() public view returns (uint256) {
// calculations pulled directly from CVX's contract for minting CVX per CRV claimed
uint256 totalCliffs = 1_000;
uint256 maxSupply = 100 * 1_000_000 * 1e18; // 100mil
uint256 reductionPerCliff = 100_000 * 1e18; // 100,000
uint256 supply = convexToken.totalSupply();
uint256 mintableCvx;
uint256 cliff = supply.div(reductionPerCliff);
uint256 _claimableBal = claimableBalance();
//mint if below total cliffs
if (cliff < totalCliffs) {
//for reduction% take inverse of current cliff
uint256 reduction = totalCliffs.sub(cliff);
//reduce
mintableCvx = _claimableBal.mul(reduction).div(totalCliffs);
//supply cap check
uint256 amtTillMax = maxSupply.sub(supply);
if (mintableCvx > amtTillMax) {
mintableCvx = amtTillMax;
}
}
// our chainlink oracle returns prices normalized to 8 decimals, we convert it to 6
IOracle ethOracle = IOracle(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419);
uint256 ethPrice = ethOracle.latestAnswer().div(1e2); // 1e8 div 1e2 = 1e6
uint256 crvPrice = crveth.price_oracle().mul(ethPrice).div(1e18); // 1e18 mul 1e6 div 1e18 = 1e6
uint256 cvxPrice = cvxeth.price_oracle().mul(ethPrice).div(1e18); // 1e18 mul 1e6 div 1e18 = 1e6
uint256 crvValue = crvPrice.mul(_claimableBal).div(1e18); // 1e6 mul 1e18 div 1e18 = 1e6
uint256 cvxValue = cvxPrice.mul(mintableCvx).div(1e18); // 1e6 mul 1e18 div 1e18 = 1e6
return crvValue.add(cvxValue);
}
// convert our keeper's eth cost into want (too much of a pain for Fixed Forex, and doesn't give much use)
function ethToWant(uint256 _ethAmount)
public
view
override
returns (uint256)
{
return _ethAmount;
}
// check if the current baseFee is below our external target
function isBaseFeeAcceptable() internal view returns (bool) {
return
IBaseFee(0xb5e1CAcB567d98faaDB60a1fD4820720141f064F)
.isCurrentBaseFeeAcceptable();
}
/* ========== SYNTHETIX ========== */
// claim and swap our CRV for synths
function claimAndSell() internal {
// if we have anything in the gauge, then harvest CRV from the gauge
if (claimableBalance() > 0) {
// check if we have any CRV to claim
// this claims our CRV, CVX, and any extra tokens.
IConvexRewards(rewardsContract).getReward(address(this), true);
uint256 _crvBalance = crv.balanceOf(address(this));
uint256 _convexBalance = convexToken.balanceOf(address(this));
uint256 _sendToVoter =
_crvBalance.mul(keepCRV).div(FEE_DENOMINATOR);
if (_sendToVoter > 0) {
crv.safeTransfer(voter, _sendToVoter);
}
uint256 _crvRemainder = crv.balanceOf(address(this));
// sell the rest of our CRV and our CVX for ETH
_sellCrvAndCvx(_crvRemainder, _convexBalance);
// sell any rKP3R we may have for WETH if our setter is true
uint256 rkprBalance = rkpr.balanceOf(address(this));
if (doSellRkpr && rkprBalance > 0) {
_sellRkpr(rkprBalance);
}
// convert our ETH into sETH
uint256 ethBalance = address(this).balance;
if (ethBalance > 0) {
setheth.exchange{value: ethBalance}(0, 1, ethBalance, 0);
}
// check our output balance of sETH
uint256 _sEthBalance = sethProxy.balanceOf(address(this));
// swap our sETH for our underlying synth if the forex markets are open
if (!isMarketClosed()) {
exchangeSEthToSynth(_sEthBalance);
}
}
}
function exchangeSEthToSynth(uint256 amount) internal returns (uint256) {
// swap amount of sETH for Synth
if (amount == 0) {
return 0;
}
return
_synthetix().exchangeWithTracking(
sethCurrencyKey,
amount,
synthCurrencyKey,
address(this),
TRACKING_CODE
);
}
function _synthetix() internal view returns (ISynthetix) {
return ISynthetix(resolver().getAddress(CONTRACT_SYNTHETIX));
}
function resolver() internal view returns (IAddressResolver) {
return IAddressResolver(readProxy.target());
}
function _exchanger() internal view returns (IExchanger) {
return IExchanger(resolver().getAddress(CONTRACT_EXCHANGER));
}
function checkWaitingPeriod() internal view returns (bool freeToMove) {
return
// check if it's been >5 mins since we traded our sETH for our synth
_exchanger().maxSecsLeftInWaitingPeriod(
address(this),
synthCurrencyKey
) == 0;
}
function isMarketClosed() public view returns (bool) {
// set up our arrays to use
bool[] memory tradingSuspended;
bytes32[] memory synthArray;
// use our synth key
synthArray = new bytes32[](1);
synthArray[0] = synthCurrencyKey;
// check if trading is open or not. true = market is closed
(tradingSuspended, ) = systemStatus.getSynthExchangeSuspensions(
synthArray
);
return tradingSuspended[0];
}
// check if someone needs to earmark rewards on convex before keepers harvest again
function needsEarmarkReward() public view returns (bool needsEarmark) {
// check if there is any CRV we need to earmark
uint256 crvExpiry = rewardsContract.periodFinish();
if (crvExpiry < block.timestamp) {
return true;
}
}
// include so our contract plays nicely with ether
receive() external payable {}
/* ========== SETTERS ========== */
// Min profit to start checking for harvests if gas is good, max will harvest no matter gas (both in USDT, 6 decimals). Credit threshold is in want token, and will trigger a harvest if credit is large enough. check earmark to look at convex's booster.
function setHarvestTriggerParams(
uint256 _harvestProfitMin,
uint256 _harvestProfitMax,
uint256 _creditThreshold,
bool _checkEarmark
) external onlyEmergencyAuthorized {
harvestProfitMin = _harvestProfitMin;
harvestProfitMax = _harvestProfitMax;
creditThreshold = _creditThreshold;
checkEarmark = _checkEarmark;
}
// turn this off if we don't want to automatically sell our rkp3r claimed
function setDoSellRkpr(bool _doSellRkpr) external onlyEmergencyAuthorized {
doSellRkpr = _doSellRkpr;
}
} | We usually don't need to claim rewards on withdrawals, but might change our mind for migrations etc | function setClaimRewards(bool _claimRewards)
external
onlyEmergencyAuthorized
{
claimRewards = _claimRewards;
}
| 7,998,345 | [
1,
3218,
11234,
2727,
1404,
1608,
358,
7516,
283,
6397,
603,
598,
9446,
1031,
16,
1496,
4825,
2549,
3134,
22838,
364,
9814,
5527,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
444,
9762,
17631,
14727,
12,
6430,
389,
14784,
17631,
14727,
13,
203,
3639,
3903,
203,
3639,
1338,
1514,
24530,
15341,
203,
565,
288,
203,
3639,
7516,
17631,
14727,
273,
389,
14784,
17631,
14727,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/69/0x7B2AD0F401Eac4ec230f2Ecb0541685E327D2f33/sources/contracts/ShineToken.sol | * @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`./unchecked {} | function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
uint256 currentAllowance = allowances[msg.sender][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(msg.sender, spender, currentAllowance - subtractedValue);
return true;
}
| 13,239,498 | [
1,
3641,
6478,
23850,
3304,
326,
1699,
1359,
17578,
358,
1375,
87,
1302,
264,
68,
635,
326,
4894,
18,
1220,
353,
392,
10355,
358,
288,
12908,
537,
97,
716,
848,
506,
1399,
487,
279,
20310,
360,
367,
364,
9688,
11893,
316,
288,
45,
654,
39,
3462,
17,
12908,
537,
5496,
7377,
1282,
392,
288,
23461,
97,
871,
11193,
326,
3526,
1699,
1359,
18,
29076,
30,
300,
1375,
87,
1302,
264,
68,
2780,
506,
326,
3634,
1758,
18,
300,
1375,
87,
1302,
264,
68,
1297,
1240,
1699,
1359,
364,
326,
4894,
434,
622,
4520,
1375,
1717,
1575,
329,
620,
8338,
19,
5847,
2618,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
20467,
7009,
1359,
12,
2867,
17571,
264,
16,
2254,
5034,
10418,
329,
620,
13,
1071,
1135,
261,
6430,
13,
288,
203,
3639,
2254,
5034,
783,
7009,
1359,
273,
1699,
6872,
63,
3576,
18,
15330,
6362,
87,
1302,
264,
15533,
203,
3639,
2583,
12,
2972,
7009,
1359,
1545,
10418,
329,
620,
16,
315,
654,
39,
3462,
30,
23850,
8905,
1699,
1359,
5712,
3634,
8863,
203,
5411,
389,
12908,
537,
12,
3576,
18,
15330,
16,
17571,
264,
16,
783,
7009,
1359,
300,
10418,
329,
620,
1769,
203,
203,
3639,
327,
638,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
/**
โโโ โโ โโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโ โโโโโโโ โโโโโโ โโโโโโ โโโโโ โโโโโโโ โโโโโโโ
โโโโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโ โโโโโโโ โโโโโโโ
โโโโโโโโโโโโโโ โโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโ โโโโโโโ โโโโโ โโโโโโ โโโโโ โโโโโโโ
โโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
Trust math, not hardware.
*/
pragma solidity 0.5.17;
import "@keep-network/keep-core/contracts/KeepToken.sol";
import "@keep-network/keep-core/contracts/TokenStaking.sol";
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol";
import "openzeppelin-solidity/contracts/cryptography/MerkleProof.sol";
/// @title ECDSA Rewards distributor
/// @notice This contract can be used by stakers to claim their rewards for
/// participation in the keep network for operating ECDSA nodes.
/// @dev This contract is based on the Uniswap's Merkle Distributor
/// https://github.com/Uniswap/merkle-distributor with some modifications:
/// - added a map of merkle root keys. Whenever a new merkle root is put in the
/// map, we assign 'true' value to this key
/// - added 'allocate()' function that will be called each time to allocate
/// new KEEP rewards for a given merkle root. Merkle root is going to be generated
/// regulary (ex. every week) and it is also means that an interval for that
/// merkle root has passed
/// - changed code accordingly to process claimed rewards using a map of merkle
/// roots
contract ECDSARewardsDistributor is Ownable {
using SafeERC20 for KeepToken;
KeepToken public token;
TokenStaking public tokenStaking;
// This event is triggered whenever a call to #claim succeeds.
event RewardsClaimed(
bytes32 indexed merkleRoot,
uint256 indexed index,
address indexed operator,
address beneficiary,
uint256 amount
);
// This event is triggered whenever rewards are allocated.
event RewardsAllocated(bytes32 merkleRoot, uint256 amount);
// Map of merkle roots indicating whether a given interval was allocated with
// KEEP token rewards. For each interval there is always created a new merkle
// tree including a root, rewarded operators along with their amounts and proofs.
mapping(bytes32 => bool) private merkleRoots;
// Bytes32 key is a merkle root and the value is a packed array of booleans.
mapping(bytes32 => mapping(uint256 => uint256)) private claimedBitMap;
constructor(address _token, address _tokenStaking) public {
token = KeepToken(_token);
tokenStaking = TokenStaking(_tokenStaking);
}
/// Claim KEEP rewards for a given merkle root (interval) and the given operator
/// address. Rewards will be sent to a beneficiary assigned to the operator.
/// @param merkleRoot Merkle root for a given interval.
/// @param index Index of the operator in the merkle tree.
/// @param operator Operator address that reward will be claimed.
/// @param amount The amount of KEEP reward to be claimed.
/// @param merkleProof Array of merkle proofs.
function claim(
bytes32 merkleRoot,
uint256 index,
address operator,
uint256 amount,
bytes32[] calldata merkleProof
) external {
require(
merkleRoots[merkleRoot],
"Rewards must be allocated for a given merkle root"
);
require(!isClaimed(merkleRoot, index), "Reward already claimed");
// Verify the merkle proof.
bytes32 node = keccak256(abi.encodePacked(index, operator, amount));
require(
MerkleProof.verify(merkleProof, merkleRoot, node),
"Invalid proof"
);
// Mark it claimed and send the token.
_setClaimed(merkleRoot, index);
address beneficiary = tokenStaking.beneficiaryOf(operator);
require(IERC20(token).transfer(beneficiary, amount), "Transfer failed");
emit RewardsClaimed(merkleRoot, index, operator, beneficiary, amount);
}
/// Allocates amount of KEEP for a given merkle root.
/// @param merkleRoot Merkle root for a given interval.
/// @param amount The amount of KEEP tokens allocated for the merkle root.
function allocate(bytes32 merkleRoot, uint256 amount) public onlyOwner {
token.safeTransferFrom(msg.sender, address(this), amount);
merkleRoots[merkleRoot] = true;
emit RewardsAllocated(merkleRoot, amount);
}
function isClaimed(bytes32 merkleRoot, uint256 index)
public
view
returns (bool)
{
uint256 claimedWordIndex = index / 256;
uint256 claimedBitIndex = index % 256;
uint256 claimedWord = claimedBitMap[merkleRoot][claimedWordIndex];
uint256 mask = (1 << claimedBitIndex);
return claimedWord & mask == mask;
}
function _setClaimed(bytes32 merkleRoot, uint256 index) private {
uint256 claimedWordIndex = index / 256;
uint256 claimedBitIndex = index % 256;
claimedBitMap[merkleRoot][claimedWordIndex] =
claimedBitMap[merkleRoot][claimedWordIndex] |
(1 << claimedBitIndex);
}
}
pragma solidity 0.5.17;
import "@keep-network/keep-core/contracts/PhasedEscrow.sol";
/// @title ECDSARewardsEscrowBeneficiary
/// @notice Transfer the received tokens from PhasedEscrow to a designated
/// ECDSARewards contract.
contract ECDSARewardsEscrowBeneficiary is StakerRewardsBeneficiary {
constructor(IERC20 _token, IStakerRewards _stakerRewards)
public
StakerRewardsBeneficiary(_token, _stakerRewards)
{}
}
/// @title ECDSABackportRewardsEscrowBeneficiary
/// @notice Trasfer the received tokens from Phased Escrow to a designated
/// ECDSABackportRewards contract.
contract ECDSABackportRewardsEscrowBeneficiary is StakerRewardsBeneficiary {
constructor(IERC20 _token, IStakerRewards _stakerRewards)
public
StakerRewardsBeneficiary(_token, _stakerRewards)
{}
}
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
import "openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol";
import "./Escrow.sol";
interface IBeneficiaryContract {
function __escrowSentTokens(uint256 amount) external;
}
/// @title PhasedEscrow
/// @notice A token holder contract allowing contract owner to set beneficiary of
/// tokens held by the contract and allowing the owner to withdraw the
/// tokens to that beneficiary in phases.
contract PhasedEscrow is Ownable {
using SafeERC20 for IERC20;
event BeneficiaryUpdated(address beneficiary);
event TokensWithdrawn(address beneficiary, uint256 amount);
IERC20 public token;
IBeneficiaryContract public beneficiary;
constructor(IERC20 _token) public {
token = _token;
}
/// @notice Funds the escrow by transferring all of the approved tokens
/// to the escrow.
function receiveApproval(
address _from,
uint256 _value,
address _token,
bytes memory
) public {
require(IERC20(_token) == token, "Unsupported token");
token.safeTransferFrom(_from, address(this), _value);
}
/// @notice Sets the provided address as a beneficiary allowing it to
/// withdraw all tokens from escrow. This function can be called only
/// by escrow owner.
function setBeneficiary(IBeneficiaryContract _beneficiary) external onlyOwner {
beneficiary = _beneficiary;
emit BeneficiaryUpdated(address(beneficiary));
}
/// @notice Withdraws the specified number of tokens from escrow to the
/// beneficiary. If the beneficiary is not set, or there are
/// insufficient tokens in escrow, the function fails.
function withdraw(uint256 amount) external onlyOwner {
require(address(beneficiary) != address(0), "Beneficiary not assigned");
uint256 balance = token.balanceOf(address(this));
require(amount <= balance, "Not enough tokens for withdrawal");
token.safeTransfer(address(beneficiary), amount);
emit TokensWithdrawn(address(beneficiary), amount);
beneficiary.__escrowSentTokens(amount);
}
/// @notice Withdraws all funds from a non-phased Escrow passed as
/// a parameter. For this function to succeed, this PhasedEscrow
/// has to be set as a beneficiary of the non-phased Escrow.
function withdrawFromEscrow(Escrow _escrow) public {
_escrow.withdraw();
}
}
interface ICurveRewards {
function notifyRewardAmount(uint256 amount) external;
}
/// @title CurveRewardsEscrowBeneficiary
/// @notice A beneficiary contract that can receive a withdrawal phase from a
/// PhasedEscrow contract. Immediately stakes the received tokens on a
/// designated CurveRewards contract.
contract CurveRewardsEscrowBeneficiary is Ownable {
IERC20 public token;
ICurveRewards public curveRewards;
constructor(IERC20 _token, ICurveRewards _curveRewards) public {
token = _token;
curveRewards = _curveRewards;
}
function __escrowSentTokens(uint256 amount) external onlyOwner {
token.approve(address(curveRewards), amount);
curveRewards.notifyRewardAmount(amount);
}
}
/// @dev Interface of recipient contract for approveAndCall pattern.
interface IStakerRewards {
function receiveApproval(
address _from,
uint256 _value,
address _token,
bytes calldata _extraData
) external;
}
/// @title StakerRewardsBeneficiary
/// @notice An abstract beneficiary contract that can receive a withdrawal phase
/// from a PhasedEscrow contract. The received tokens are immediately
/// funded for a designated rewards escrow beneficiary contract.
contract StakerRewardsBeneficiary is Ownable {
IERC20 public token;
IStakerRewards public stakerRewards;
constructor(IERC20 _token, IStakerRewards _stakerRewards) public {
token = _token;
stakerRewards = _stakerRewards;
}
function __escrowSentTokens(uint256 amount) external onlyOwner {
bool success = token.approve(address(stakerRewards), amount);
require(success, "Token transfer approval failed");
stakerRewards.receiveApproval(
address(this),
amount,
address(token),
""
);
}
}
/// @title BeaconBackportRewardsEscrowBeneficiary
/// @notice Transfer the received tokens to a designated
/// BeaconBackportRewardsEscrowBeneficiary contract.
contract BeaconBackportRewardsEscrowBeneficiary is StakerRewardsBeneficiary {
constructor(IERC20 _token, IStakerRewards _stakerRewards)
public
StakerRewardsBeneficiary(_token, _stakerRewards)
{}
}
/// @title BeaconRewardsEscrowBeneficiary
/// @notice Transfer the received tokens to a designated
/// BeaconRewardsEscrowBeneficiary contract.
contract BeaconRewardsEscrowBeneficiary is StakerRewardsBeneficiary {
constructor(IERC20 _token, IStakerRewards _stakerRewards)
public
StakerRewardsBeneficiary(_token, _stakerRewards)
{}
}
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
import "openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol";
// @title Escrow
// @notice A token holder contract allowing contract owner to set beneficiary of
// all tokens held by the contract and allowing the beneficiary to withdraw
// the tokens.
contract Escrow is Ownable {
using SafeERC20 for IERC20;
event BeneficiaryUpdated(address beneficiary);
event TokensWithdrawn(address beneficiary, uint256 amount);
IERC20 public token;
address public beneficiary;
constructor(IERC20 _token) public {
token = _token;
}
// @notice Sets the provided address as a beneficiary allowing it to
// withdraw all tokens from escrow. This function can be called only
// by escrow owner.
function setBeneficiary(address _beneficiary) public onlyOwner {
beneficiary = _beneficiary;
emit BeneficiaryUpdated(beneficiary);
}
// @notice Withdraws all tokens from escrow to the beneficiary.
// If the beneficiary is not set, caller is not the beneficiary, or there
// are no tokens in escrow, function fails.
function withdraw() public {
require(beneficiary != address(0), "Beneficiary not assigned");
require(msg.sender == beneficiary, "Caller is not the beneficiary");
uint256 amount = token.balanceOf(address(this));
require(amount > 0, "No tokens to withdraw");
token.safeTransfer(beneficiary, amount);
emit TokensWithdrawn(beneficiary, amount);
}
}
pragma solidity ^0.5.0;
/**
* @dev These functions deal with verification of Merkle trees (hash trees),
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash < proofElement) {
// Hash(current computed hash + current element of the proof)
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
// Hash(current element of the proof + current computed hash)
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
// Check if the computed hash (root) is equal to the provided root
return computedHash == root;
}
}
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol";
/// @dev Interface of recipient contract for approveAndCall pattern.
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
/// @title KEEP Token
/// @dev Standard ERC20Burnable token
contract KeepToken is ERC20Burnable, ERC20Detailed {
string public constant NAME = "KEEP Token";
string public constant SYMBOL = "KEEP";
uint8 public constant DECIMALS = 18; // The number of digits after the decimal place when displaying token values on-screen.
uint256 public constant INITIAL_SUPPLY = 10**27; // 1 billion tokens, 18 decimal places.
/// @dev Gives msg.sender all of existing tokens.
constructor() public ERC20Detailed(NAME, SYMBOL, DECIMALS) {
_mint(msg.sender, INITIAL_SUPPLY);
}
/// @notice Set allowance for other address and notify.
/// Allows `_spender` to spend no more than `_value` tokens
/// on your behalf and then ping the contract about it.
/// @param _spender The address authorized to spend.
/// @param _value The max amount they can spend.
/// @param _extraData Extra information to send to the approved contract.
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
}
pragma solidity ^0.5.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.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be aplied to your functions to restrict their use to
* the owner.
*/
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @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(isOwner(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view returns (bool) {
return msg.sender == _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 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 onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma solidity ^0.5.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) {
require(b <= a, "SafeMath: subtraction overflow");
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-solidity/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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
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) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
pragma solidity ^0.5.0;
import "./ERC20.sol";
/**
* @dev Extension of `ERC20` that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/
contract ERC20Burnable is ERC20 {
/**
* @dev Destoys `amount` tokens from the caller.
*
* See `ERC20._burn`.
*/
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
/**
* @dev See `ERC20._burnFrom`.
*/
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
pragma solidity ^0.5.0;
import "./IERC20.sol";
import "../../math/SafeMath.sol";
/**
* @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 `ERC20Mintable`.
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226).*
*
* 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 IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev See `IERC20.balanceOf`.
*/
function balanceOf(address account) public view 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 returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
/**
* @dev See `IERC20.allowance`.
*/
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See `IERC20.approve`.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
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 `value`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(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 returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][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 returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(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 {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_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 {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destoys `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 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
/**
* @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 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
/**
* @dev Destoys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See `_burn` and `_approve`.
*/
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
}
pragma solidity ^0.5.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see `ERC20Detailed`.
*/
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.
*
* > 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.5.0;
import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity ^0.5.0;
/**
* @dev Collection of functions related to the address type,
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* This test is non-exhaustive, and there may be false-negatives: during the
* execution of a contract's constructor, its address will be reported as
* not containing a contract.
*
* > It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*/
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
pragma solidity ^0.5.0;
import "./IERC20.sol";
/**
* @dev Optional functions from the ERC20 standard.
*/
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
* these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @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.
*
* > Note that 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;
}
}
/**
โโโ โโ โโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโ โโโโโโโ โโโโโโ โโโโโโ โโโโโ โโโโโโโ โโโโโโโ
โโโโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโ โโโโโโโ โโโโโโโ
โโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโ โโโโโโโ โโโโโ โโโโโโ โโโโโ โโโโโโโ
โโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
Trust math, not hardware.
*/
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "./StakeDelegatable.sol";
import "./libraries/staking/MinimumStakeSchedule.sol";
import "./libraries/staking/GrantStaking.sol";
import "./libraries/staking/Locks.sol";
import "./libraries/staking/TopUps.sol";
import "./utils/PercentUtils.sol";
import "./utils/BytesLib.sol";
import "./Authorizations.sol";
import "./TokenStakingEscrow.sol";
import "./TokenSender.sol";
/// @title TokenStaking
/// @notice A token staking contract for a specified standard ERC20Burnable token.
/// A holder of the specified token can stake delegate its tokens to this contract
/// and recover the stake after undelegation period is over.
contract TokenStaking is Authorizations, StakeDelegatable {
using BytesLib for bytes;
using SafeMath for uint256;
using PercentUtils for uint256;
using SafeERC20 for ERC20Burnable;
using GrantStaking for GrantStaking.Storage;
using Locks for Locks.Storage;
using TopUps for TopUps.Storage;
event StakeDelegated(
address indexed owner,
address indexed operator
);
event OperatorStaked(
address indexed operator,
address indexed beneficiary,
address indexed authorizer,
uint256 value
);
event StakeOwnershipTransferred(
address indexed operator,
address indexed newOwner
);
event TopUpInitiated(address indexed operator, uint256 topUp);
event TopUpCompleted(address indexed operator, uint256 newAmount);
event Undelegated(address indexed operator, uint256 undelegatedAt);
event RecoveredStake(address operator);
event TokensSlashed(address indexed operator, uint256 amount);
event TokensSeized(address indexed operator, uint256 amount);
event StakeLocked(address indexed operator, address lockCreator, uint256 until);
event LockReleased(address indexed operator, address lockCreator);
event ExpiredLockReleased(address indexed operator, address lockCreator);
uint256 public deployedAt;
uint256 public initializationPeriod; // varies between mainnet and testnet
ERC20Burnable internal token;
TokenGrant internal tokenGrant;
TokenStakingEscrow internal escrow;
GrantStaking.Storage internal grantStaking;
Locks.Storage internal locks;
TopUps.Storage internal topUps;
uint256 internal constant twoWeeks = 1209600; // [sec]
uint256 internal constant twoMonths = 5184000; // [sec]
// 2020-04-28; the date of deploying KEEP token.
// TX: 0xea22d72bc7de4c82798df7194734024a1f2fd57b173d0e065864ff4e9d3dc014
uint256 internal constant minimumStakeScheduleStart = 1588042366;
/// @notice Creates a token staking contract for a provided Standard ERC20Burnable token.
/// @param _token KEEP token contract.
/// @param _tokenGrant KEEP token grant contract.
/// @param _escrow Escrow dedicated for this staking contract.
/// @param _registry Keep contract registry contract.
/// @param _initializationPeriod To avoid certain attacks on work selection, recently created
/// operators must wait for a specific period of time before being eligible for work selection.
constructor(
ERC20Burnable _token,
TokenGrant _tokenGrant,
TokenStakingEscrow _escrow,
KeepRegistry _registry,
uint256 _initializationPeriod
) Authorizations(_registry) public {
token = _token;
tokenGrant = _tokenGrant;
escrow = _escrow;
registry = _registry;
initializationPeriod = _initializationPeriod;
deployedAt = block.timestamp;
}
/// @notice Returns minimum amount of KEEP that allows sMPC cluster client to
/// participate in the Keep network. Expressed as number with 18-decimal places.
/// Initial minimum stake is higher than the final and lowered periodically based
/// on the amount of steps and the length of the minimum stake schedule in seconds.
function minimumStake() public view returns (uint256) {
return MinimumStakeSchedule.current(minimumStakeScheduleStart);
}
/// @notice Returns the current value of the undelegation period.
/// The staking contract guarantees that an undelegated operatorโs stakes
/// will stay locked for a period of time after undelegation, and thus
/// available as collateral for any work the operator is engaged in.
/// The undelegation period is two weeks for the first two months and
/// two months after that.
function undelegationPeriod() public view returns(uint256) {
return block.timestamp < deployedAt.add(twoMonths) ? twoWeeks : twoMonths;
}
/// @notice Receives approval of token transfer and stakes the approved
/// amount or adds the approved amount to an existing delegation (a โtop-upโ).
/// In case of a top-up, it is expected that the operator stake is not
/// undelegated and that the top-up is performed from the same source of
/// tokens as the initial delegation. That is, if the tokens were delegated
/// from a grant, top-up has to be performed from the same grant. If the
/// delegation was done using liquid tokens, only liquid tokens from the
/// same owner can be used to top-up the stake.
/// Top-up can not be cancelled so it is important to be careful with the
/// amount of KEEP added to the stake.
/// @dev Requires that the provided token contract be the same one linked to
/// this contract.
/// @param _from The owner of the tokens who approved them to transfer.
/// @param _value Approved amount for the transfer and stake.
/// @param _token Token contract address.
/// @param _extraData Data for stake delegation. This byte array must have
/// the following values concatenated:
/// - Beneficiary address (20 bytes), ignored for a top-up
/// - Operator address (20 bytes)
/// - Authorizer address (20 bytes), ignored for a top-up
/// - Grant ID (32 bytes) - required only when called by TokenStakingEscrow
function receiveApproval(
address _from,
uint256 _value,
address _token,
bytes memory _extraData
) public {
require(ERC20Burnable(_token) == token, "Unrecognized token");
require(_extraData.length >= 60, "Corrupted delegation data");
// Transfer tokens to this contract.
token.safeTransferFrom(_from, address(this), _value);
address operator = _extraData.toAddress(20);
// See if there is an existing delegation for this operator...
if (operators[operator].packedParams.getCreationTimestamp() == 0) {
// If there is no existing delegation, delegate tokens using
// beneficiary and authorizer passed in _extraData.
delegate(_from, _value, operator, _extraData);
} else {
// If there is an existing delegation, top-up the stake.
topUp(_from, _value, operator, _extraData);
}
}
/// @notice Delegates tokens to a new operator using beneficiary and
/// authorizer passed in _extraData parameter.
/// @param _from The owner of the tokens who approved them to transfer.
/// @param _value Approved amount for the transfer and stake.
/// @param _operator The new operator address.
/// @param _extraData Data for stake delegation as passed to receiveApproval.
function delegate(
address _from,
uint256 _value,
address _operator,
bytes memory _extraData
) internal {
require(_value >= minimumStake(), "Less than the minimum stake");
address payable beneficiary = address(uint160(_extraData.toAddress(0)));
address authorizer = _extraData.toAddress(40);
operators[_operator] = Operator(
OperatorParams.pack(_value, block.timestamp, 0),
_from,
beneficiary,
authorizer
);
grantStaking.tryCapturingDelegationData(
tokenGrant,
address(escrow),
_from,
_operator,
_extraData
);
emit StakeDelegated(_from, _operator);
emit OperatorStaked(_operator, beneficiary, authorizer, _value);
}
/// @notice Performs top-up to an existing operator. Tokens added during
/// stake initialization period are immediatelly added to the stake and
/// stake initialization timer is reset to the current block. Tokens added
/// in a top-up after the stake initialization period is over are not
/// included in the operator stake until the initialization period for
/// a top-up passes and top-up is committed. Operator must not have the stake
/// undelegated. It is expected that the top-up is done from the same source
/// of tokens as the initial delegation. That is, if the tokens were
/// delegated from a grant, top-up has to be performed from the same grant.
/// If the delegation was done using liquid tokens, only liquid tokens from
/// the same owner can be used to top-up the stake.
/// Top-up can not be cancelled so it is important to be careful with the
/// amount of KEEP added to the stake.
/// @param _from The owner of the tokens who approved them to transfer.
/// @param _value Approved amount for the transfer and top-up to
/// an existing stake.
/// @param _operator The new operator address.
/// @param _extraData Data for stake delegation as passed to receiveApproval
function topUp(
address _from,
uint256 _value,
address _operator,
bytes memory _extraData
) internal {
// Top-up comes from a grant if it's been initiated from TokenGrantStake
// contract or if it's been initiated from TokenStakingEscrow by
// redelegation.
bool isFromGrant = address(tokenGrant.grantStakes(_operator)) == _from ||
address(escrow) == _from;
if (grantStaking.hasGrantDelegated(_operator)) {
// Operator has grant delegated. We need to see if the top-up
// is performed also from a grant.
require(isFromGrant, "Must be from a grant");
// If it is from a grant, we need to make sure it's from the same
// grant as the original delegation. We do not want to mix unlocking
// schedules.
uint256 previousGrantId = grantStaking.getGrantForOperator(_operator);
(, uint256 grantId) = grantStaking.tryCapturingDelegationData(
tokenGrant, address(escrow), _from, _operator, _extraData
);
require(grantId == previousGrantId, "Not the same grant");
} else {
// Operator has no grant delegated. We need to see if the top-up
// is performed from liquid tokens of the same owner.
require(!isFromGrant, "Must not be from a grant");
require(operators[_operator].owner == _from, "Not the same owner");
}
uint256 operatorParams = operators[_operator].packedParams;
if (!_isInitialized(operatorParams)) {
// If the stake is not yet initialized, we add tokens immediately
// but we also reset stake initialization time counter.
operators[_operator].packedParams = topUps.instantComplete(
_value, _operator, operatorParams, escrow
);
} else {
// If the stake is initialized, we do NOT add tokens immediately.
// We initiate the top-up and will add tokens to the stake only
// after the initialization period for a top-up passes.
topUps.initiate(_value, _operator, operatorParams, escrow);
}
}
/// @notice Commits pending top-up for the provided operator. If the top-up
/// did not pass the initialization period, the function fails.
/// @param _operator The operator with a pending top-up that is getting
/// committed.
function commitTopUp(address _operator) public {
operators[_operator].packedParams = topUps.commit(
_operator,
operators[_operator].packedParams,
initializationPeriod
);
}
/// @notice Cancels stake of tokens within the operator initialization period
/// without being subjected to the token lockup for the undelegation period.
/// This can be used to undo mistaken delegation to the wrong operator address.
/// @param _operator Address of the stake operator.
function cancelStake(address _operator) public {
address owner = operators[_operator].owner;
require(
msg.sender == owner ||
msg.sender == _operator ||
grantStaking.canUndelegate(_operator, tokenGrant),
"Not authorized"
);
uint256 operatorParams = operators[_operator].packedParams;
require(
!_isInitialized(operatorParams),
"Initialized stake"
);
uint256 amount = operatorParams.getAmount();
operators[_operator].packedParams = operatorParams.setAmount(0);
transferOrDeposit(owner, _operator, amount);
}
/// @notice Undelegates staked tokens. You will be able to recover your stake by calling
/// `recoverStake()` with operator address once undelegation period is over.
/// @param _operator Address of the stake operator.
function undelegate(address _operator) public {
undelegateAt(_operator, block.timestamp);
}
/// @notice Set an undelegation time for staked tokens.
/// Undelegation will begin at the specified timestamp.
/// You will be able to recover your stake by calling
/// `recoverStake()` with operator address once undelegation period is over.
/// @param _operator Address of the stake operator.
/// @param _undelegationTimestamp The timestamp undelegation is to start at.
function undelegateAt(
address _operator,
uint256 _undelegationTimestamp
) public {
require(
msg.sender == _operator ||
msg.sender == operators[_operator].owner ||
grantStaking.canUndelegate(_operator, tokenGrant),
"Not authorized"
);
uint256 oldParams = operators[_operator].packedParams;
require(
_undelegationTimestamp >= block.timestamp &&
_undelegationTimestamp > oldParams.getCreationTimestamp().add(initializationPeriod),
"Invalid timestamp"
);
uint256 existingUndelegationTimestamp = oldParams.getUndelegationTimestamp();
require(
// Undelegation not in progress OR
existingUndelegationTimestamp == 0 ||
// Undelegating sooner than previously set time OR
existingUndelegationTimestamp > _undelegationTimestamp ||
// We have already checked above that msg.sender is owner, grantee,
// or operator. Only owner and grantee are eligible to postpone the
// delegation so it is enough if we exclude operator here.
msg.sender != _operator,
"Operator may not postpone"
);
operators[_operator].packedParams = oldParams.setUndelegationTimestamp(
_undelegationTimestamp
);
emit Undelegated(_operator, _undelegationTimestamp);
}
/// @notice Recovers staked tokens and transfers them back to the owner.
/// Recovering tokens can only be performed when the operator finished
/// undelegating.
/// @param _operator Operator address.
function recoverStake(address _operator) public {
uint256 operatorParams = operators[_operator].packedParams;
require(
operatorParams.getUndelegationTimestamp() != 0,
"Not undelegated"
);
require(
_isUndelegatingFinished(operatorParams),
"Still undelegating"
);
require(
!isStakeLocked(_operator),
"Locked stake"
);
uint256 amount = operatorParams.getAmount();
// If there is a pending top-up, force-commit it before returning tokens.
amount = amount.add(topUps.cancel(_operator));
operators[_operator].packedParams = operatorParams.setAmount(0);
transferOrDeposit(operators[_operator].owner, _operator, amount);
emit RecoveredStake(_operator);
}
/// @notice Gets stake delegation info for the given operator.
/// @param _operator Operator address.
/// @return amount The amount of tokens the given operator delegated.
/// @return createdAt The time when the stake has been delegated.
/// @return undelegatedAt The time when undelegation has been requested.
/// If undelegation has not been requested, 0 is returned.
function getDelegationInfo(address _operator)
public view returns (uint256 amount, uint256 createdAt, uint256 undelegatedAt) {
return operators[_operator].packedParams.unpack();
}
/// @notice Locks given operator stake for the specified duration.
/// Locked stake may not be recovered until the lock expires or is released,
/// even if the normal undelegation period has passed.
/// Only previously authorized operator contract can lock the stake.
/// @param operator Operator address.
/// @param duration Lock duration in seconds.
function lockStake(
address operator,
uint256 duration
) public onlyApprovedOperatorContract(msg.sender) {
require(
isAuthorizedForOperator(operator, msg.sender),
"Not authorized"
);
uint256 operatorParams = operators[operator].packedParams;
require(
_isInitialized(operatorParams),
"Inactive stake"
);
require(
!_isUndelegating(operatorParams),
"Undelegating stake"
);
locks.lockStake(operator, duration);
}
/// @notice Removes a lock the caller had previously placed on the operator.
/// @dev Only for operator contracts.
/// To remove expired or disabled locks, use `releaseExpiredLocks`.
/// The authorization check ensures that the caller must have been able
/// to place a lock on the operator sometime in the past.
/// We don't need to check for current approval status of the caller
/// because unlocking stake cannot harm the operator
/// nor interfere with other operator contracts.
/// Therefore even disabled operator contracts may freely unlock stake.
/// @param operator Operator address.
function unlockStake(
address operator
) public {
require(
isAuthorizedForOperator(operator, msg.sender),
"Not authorized"
);
locks.releaseLock(operator);
}
/// @notice Removes the lock of the specified operator contract
/// if the lock has expired or the contract has been disabled.
/// @dev Necessary for removing locks placed by contracts
/// that have been disabled by the panic button.
/// Also applicable to prevent inadvertent DoS of `recoverStake`
/// if too many operator contracts have failed to clean up their locks.
function releaseExpiredLock(
address operator,
address operatorContract
) public {
locks.releaseExpiredLock(operator, operatorContract, address(this));
}
/// @notice Check whether the operator has any active locks
/// that haven't expired yet
/// and whose creators aren't disabled by the panic button.
function isStakeLocked(address operator) public view returns (bool) {
return locks.isStakeLocked(operator, address(this));
}
/// @notice Get the locks placed on the operator.
/// @return creators The addresses of operator contracts
/// that have placed a lock on the operator.
/// @return expirations The expiration times
/// of the locks placed on the operator.
function getLocks(address operator)
public
view
returns (address[] memory creators, uint256[] memory expirations) {
return locks.getLocks(operator);
}
/// @notice Slash provided token amount from every member in the misbehaved
/// operators array and burn 100% of all the tokens.
/// @param amountToSlash Token amount to slash from every misbehaved operator.
/// @param misbehavedOperators Array of addresses to seize the tokens from.
function slash(uint256 amountToSlash, address[] memory misbehavedOperators)
public
onlyApprovedOperatorContract(msg.sender) {
uint256 totalAmountToBurn;
address authoritySource = getAuthoritySource(msg.sender);
for (uint i = 0; i < misbehavedOperators.length; i++) {
address operator = misbehavedOperators[i];
require(authorizations[authoritySource][operator], "Not authorized");
uint256 operatorParams = operators[operator].packedParams;
require(
_isInitialized(operatorParams),
"Inactive stake"
);
require(
!_isStakeReleased(operator, operatorParams, msg.sender),
"Stake is released"
);
uint256 currentAmount = operatorParams.getAmount();
if (currentAmount < amountToSlash) {
totalAmountToBurn = totalAmountToBurn.add(currentAmount);
operators[operator].packedParams = operatorParams.setAmount(0);
emit TokensSlashed(operator, currentAmount);
} else {
totalAmountToBurn = totalAmountToBurn.add(amountToSlash);
operators[operator].packedParams = operatorParams.setAmount(
currentAmount.sub(amountToSlash)
);
emit TokensSlashed(operator, amountToSlash);
}
}
token.burn(totalAmountToBurn);
}
/// @notice Seize provided token amount from every member in the misbehaved
/// operators array. The tattletale is rewarded with 5% of the total seized
/// amount scaled by the reward adjustment parameter and the rest 95% is burned.
/// @param amountToSeize Token amount to seize from every misbehaved operator.
/// @param rewardMultiplier Reward adjustment in percentage. Min 1% and 100% max.
/// @param tattletale Address to receive the 5% reward.
/// @param misbehavedOperators Array of addresses to seize the tokens from.
function seize(
uint256 amountToSeize,
uint256 rewardMultiplier,
address tattletale,
address[] memory misbehavedOperators
) public onlyApprovedOperatorContract(msg.sender) {
uint256 totalAmountToBurn;
address authoritySource = getAuthoritySource(msg.sender);
for (uint i = 0; i < misbehavedOperators.length; i++) {
address operator = misbehavedOperators[i];
require(authorizations[authoritySource][operator], "Not authorized");
uint256 operatorParams = operators[operator].packedParams;
require(
_isInitialized(operatorParams),
"Inactive stake"
);
require(
!_isStakeReleased(operator, operatorParams, msg.sender),
"Stake is released"
);
uint256 currentAmount = operatorParams.getAmount();
if (currentAmount < amountToSeize) {
totalAmountToBurn = totalAmountToBurn.add(currentAmount);
operators[operator].packedParams = operatorParams.setAmount(0);
emit TokensSeized(operator, currentAmount);
} else {
totalAmountToBurn = totalAmountToBurn.add(amountToSeize);
operators[operator].packedParams = operatorParams.setAmount(
currentAmount.sub(amountToSeize)
);
emit TokensSeized(operator, amountToSeize);
}
}
uint256 tattletaleReward = (totalAmountToBurn.percent(5)).percent(rewardMultiplier);
token.safeTransfer(tattletale, tattletaleReward);
token.burn(totalAmountToBurn.sub(tattletaleReward));
}
/// @notice Allows the current staking relationship owner to transfer the
/// ownership to someone else.
/// @param operator Address of the stake operator.
/// @param newOwner Address of the new staking relationship owner.
function transferStakeOwnership(address operator, address newOwner) public {
require(msg.sender == operators[operator].owner, "Not authorized");
operators[operator].owner = newOwner;
emit StakeOwnershipTransferred(operator, newOwner);
}
/// @notice Gets the eligible stake balance of the specified address.
/// An eligible stake is a stake that passed the initialization period
/// and is not currently undelegating. Also, the operator had to approve
/// the specified operator contract.
///
/// Operator with a minimum required amount of eligible stake can join the
/// network and participate in new work selection.
///
/// @param _operator address of stake operator.
/// @param _operatorContract address of operator contract.
/// @return an uint256 representing the eligible stake balance.
function eligibleStake(
address _operator,
address _operatorContract
) public view returns (uint256 balance) {
uint256 operatorParams = operators[_operator].packedParams;
// To be eligible for work selection, the operator must:
// - have the operator contract authorized
// - have the stake initialized
// - must not be undelegating; keep in mind the `undelegatedAt` may be
// set to a time in the future, to schedule undelegation in advance.
// In this case the operator is still eligible until the timestamp
// `undelegatedAt`.
if (
isAuthorizedForOperator(_operator, _operatorContract) &&
_isInitialized(operatorParams) &&
!_isUndelegating(operatorParams)
) {
balance = operatorParams.getAmount();
}
}
/// @notice Gets the active stake balance of the specified address.
/// An active stake is a stake that passed the initialization period,
/// and may be in the process of undelegation
/// but has not been released yet,
/// either because the undelegation period is not over,
/// or because the operator contract has an active lock on the operator.
/// Also, the operator had to approve the specified operator contract.
///
/// The difference between eligible stake is that active stake does not make
/// the operator eligible for work selection but it may be still finishing
/// earlier work until the stake is released.
/// Operator with a minimum required
/// amount of active stake can join the network but cannot be selected to any
/// new work.
///
/// @param _operator address of stake operator.
/// @param _operatorContract address of operator contract.
/// @return an uint256 representing the eligible stake balance.
function activeStake(
address _operator,
address _operatorContract
) public view returns (uint256 balance) {
uint256 operatorParams = operators[_operator].packedParams;
if (
isAuthorizedForOperator(_operator, _operatorContract) &&
_isInitialized(operatorParams) &&
!_isStakeReleased(
_operator,
operatorParams,
_operatorContract
)
) {
balance = operatorParams.getAmount();
}
}
/// @notice Checks if the specified account has enough active stake to become
/// network operator and that the specified operator contract has been
/// authorized for potential slashing.
///
/// Having the required minimum of active stake makes the operator eligible
/// to join the network. If the active stake is not currently undelegating,
/// operator is also eligible for work selection.
///
/// @param staker Staker's address
/// @param operatorContract Operator contract's address
/// @return True if has enough active stake to participate in the network,
/// false otherwise.
function hasMinimumStake(
address staker,
address operatorContract
) public view returns(bool) {
return activeStake(staker, operatorContract) >= minimumStake();
}
/// @notice Is the operator with the given params initialized
function _isInitialized(uint256 _operatorParams)
internal view returns (bool) {
return block.timestamp > _operatorParams.getCreationTimestamp().add(initializationPeriod);
}
/// @notice Is the operator with the given params undelegating
function _isUndelegating(uint256 _operatorParams)
internal view returns (bool) {
uint256 undelegatedAt = _operatorParams.getUndelegationTimestamp();
return (undelegatedAt != 0) && (block.timestamp > undelegatedAt);
}
/// @notice Has the operator with the given params finished undelegating
function _isUndelegatingFinished(uint256 _operatorParams)
internal view returns (bool) {
uint256 undelegatedAt = _operatorParams.getUndelegationTimestamp();
return (undelegatedAt != 0) && (block.timestamp > undelegatedAt.add(undelegationPeriod()));
}
/// @notice Get whether the operator's stake is released
/// as far as the operator contract is concerned.
/// If the operator contract has a lock on the operator,
/// the operator's stake is be released when the lock expires.
/// Otherwise the stake is released when the operator finishes undelegating.
function _isStakeReleased(
address _operator,
uint256 _operatorParams,
address _operatorContract
) internal view returns (bool) {
return _isUndelegatingFinished(_operatorParams) &&
locks.isStakeReleased(_operator, _operatorContract);
}
function transferOrDeposit(
address _owner,
address _operator,
uint256 _amount
) internal {
if (grantStaking.hasGrantDelegated(_operator)) {
// For tokens staked from a grant, transfer them to the escrow.
TokenSender(address(token)).approveAndCall(
address(escrow),
_amount,
abi.encode(_operator, grantStaking.getGrantForOperator(_operator))
);
} else {
// For liquid tokens staked, transfer them straight to the owner.
token.safeTransfer(_owner, _amount);
}
}
}
/**
โโโ โโ โโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโ โโโโโโโ โโโโโโ โโโโโโ โโโโโ โโโโโโโ โโโโโโโ
โโโโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโ โโโโโโโ โโโโโโโ
โโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโ โโโโโโโ โโโโโ โโโโโโ โโโโโ โโโโโโโ
โโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
Trust math, not hardware.
*/
pragma solidity 0.5.17;
import "./utils/OperatorParams.sol";
/// @title Stake Delegatable
/// @notice A base contract to allow stake delegation for staking contracts.
contract StakeDelegatable {
using OperatorParams for uint256;
mapping(address => Operator) internal operators;
struct Operator {
uint256 packedParams;
address owner;
address payable beneficiary;
address authorizer;
}
/// @notice Gets the stake balance of the specified address.
/// @param _address The address to query the balance of.
/// @return An uint256 representing the amount staked by the passed address.
function balanceOf(address _address) public view returns (uint256 balance) {
return operators[_address].packedParams.getAmount();
}
/// @notice Gets the stake owner for the specified operator address.
/// @return Stake owner address.
function ownerOf(address _operator) public view returns (address) {
return operators[_operator].owner;
}
/// @notice Gets the beneficiary for the specified operator address.
/// @return Beneficiary address.
function beneficiaryOf(address _operator) public view returns (address payable) {
return operators[_operator].beneficiary;
}
/// @notice Gets the authorizer for the specified operator address.
/// @return Authorizer address.
function authorizerOf(address _operator) public view returns (address) {
return operators[_operator].authorizer;
}
}
pragma solidity 0.5.17;
library OperatorParams {
// OperatorParams packs values that are commonly used together
// into a single uint256 to reduce the cost functions
// like querying eligibility.
//
// An OperatorParams uint256 contains:
// - the operator's staked token amount (uint128)
// - the operator's creation timestamp (uint64)
// - the operator's undelegation timestamp (uint64)
//
// These are packed as [amount | createdAt | undelegatedAt]
//
// Staked KEEP is stored in an uint128,
// which is sufficient because KEEP tokens have 18 decimals (2^60)
// and there will be at most 10^9 KEEP in existence (2^30).
//
// Creation and undelegation times are stored in an uint64 each.
// Thus uint64s would be sufficient for around 3*10^11 years.
uint256 constant TIMESTAMP_WIDTH = 64;
uint256 constant AMOUNT_WIDTH = 128;
uint256 constant TIMESTAMP_MAX = (2**TIMESTAMP_WIDTH) - 1;
uint256 constant AMOUNT_MAX = (2**AMOUNT_WIDTH) - 1;
uint256 constant CREATION_SHIFT = TIMESTAMP_WIDTH;
uint256 constant AMOUNT_SHIFT = 2 * TIMESTAMP_WIDTH;
function pack(
uint256 amount,
uint256 createdAt,
uint256 undelegatedAt
) internal pure returns (uint256) {
// Check for staked amount overflow.
// We shouldn't actually ever need this.
require(
amount <= AMOUNT_MAX,
"uint128 overflow"
);
// Bitwise OR the timestamps together.
// The resulting number is equal or greater than either,
// and tells if we have a bit set outside the 64 available bits.
require(
(createdAt | undelegatedAt) <= TIMESTAMP_MAX,
"uint64 overflow"
);
return (amount << AMOUNT_SHIFT | createdAt << CREATION_SHIFT | undelegatedAt);
}
function unpack(uint256 packedParams) internal pure returns (
uint256 amount,
uint256 createdAt,
uint256 undelegatedAt
) {
amount = getAmount(packedParams);
createdAt = getCreationTimestamp(packedParams);
undelegatedAt = getUndelegationTimestamp(packedParams);
}
function getAmount(uint256 packedParams)
internal pure returns (uint256) {
return (packedParams >> AMOUNT_SHIFT) & AMOUNT_MAX;
}
function setAmount(
uint256 packedParams,
uint256 amount
) internal pure returns (uint256) {
return pack(
amount,
getCreationTimestamp(packedParams),
getUndelegationTimestamp(packedParams)
);
}
function getCreationTimestamp(uint256 packedParams)
internal pure returns (uint256) {
return (packedParams >> CREATION_SHIFT) & TIMESTAMP_MAX;
}
function setCreationTimestamp(
uint256 packedParams,
uint256 creationTimestamp
) internal pure returns (uint256) {
return pack(
getAmount(packedParams),
creationTimestamp,
getUndelegationTimestamp(packedParams)
);
}
function getUndelegationTimestamp(uint256 packedParams)
internal pure returns (uint256) {
return packedParams & TIMESTAMP_MAX;
}
function setUndelegationTimestamp(
uint256 packedParams,
uint256 undelegationTimestamp
) internal pure returns (uint256) {
return pack(
getAmount(packedParams),
getCreationTimestamp(packedParams),
undelegationTimestamp
);
}
function setAmountAndCreationTimestamp(
uint256 packedParams,
uint256 amount,
uint256 creationTimestamp
) internal pure returns (uint256) {
return pack(
amount,
creationTimestamp,
getUndelegationTimestamp(packedParams)
);
}
}
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
/// @notice MinimumStakeSchedule defines the minimum stake parametrization and
/// schedule. It starts with a minimum stake of 100k KEEP. Over the following
/// 2 years, the minimum stake is lowered periodically using a uniform stepwise
/// function, eventually ending at 10k.
library MinimumStakeSchedule {
using SafeMath for uint256;
// 2 years in seconds (seconds per day * days in a year * years)
uint256 public constant schedule = 86400 * 365 * 2;
uint256 public constant steps = 10;
uint256 public constant base = 10000 * 1e18;
/// @notice Returns the current value of the minimum stake. The minimum
/// stake is lowered periodically over the course of 2 years since the time
/// of the shedule start and eventually ends at 10k KEEP.
function current(uint256 scheduleStart) internal view returns (uint256) {
if (now < scheduleStart.add(schedule)) {
uint256 currentStep = steps.mul(now.sub(scheduleStart)).div(schedule);
return base.mul(steps.sub(currentStep));
}
return base;
}
}
pragma solidity 0.5.17;
import "../../TokenGrant.sol";
import "../../TokenStakingEscrow.sol";
import "../..//utils/BytesLib.sol";
import "../RolesLookup.sol";
/// @notice TokenStaking contract library allowing to capture the details of
/// delegated grants and offering functions allowing to check grantee
/// authentication for stake delegation management.
library GrantStaking {
using BytesLib for bytes;
using RolesLookup for address payable;
/// @dev Grant ID is flagged with the most significant bit set, to
/// distinguish the grant ID `0` from default (null) value. The flag is
/// toggled with bitwise XOR (`^`) which keeps all other bits intact but
/// flips the flag bit. The flag should be set before writing to
/// `operatorToGrant`, and unset after reading from `operatorToGrant`
/// before using the value.
uint256 constant GRANT_ID_FLAG = 1 << 255;
struct Storage {
/// @dev Do not read or write this mapping directly; please use
/// `hasGrantDelegated`, `setGrantForOperator`, and `getGrantForOperator`
/// instead.
mapping (address => uint256) _operatorToGrant;
}
/// @notice Tries to capture delegation data if the pending delegation has
/// been created from a grant. There are only two possibilities and they
/// need to be handled differently: delegation comes from the TokenGrant
/// contract or delegation comes from TokenStakingEscrow. In those two cases
/// grant ID has to be captured in a different way.
/// @dev In case of a delegation from the escrow, it is expected that grant
/// ID is passed in extraData bytes array. When the delegation comes from
/// the TokenGrant contract, delegation data are obtained directly from that
/// contract using `tryCapturingGrantId` function.
/// @param tokenGrant KEEP token grant contract reference.
/// @param escrow TokenStakingEscrow contract address.
/// @param from The owner of the tokens who approved them to transfer.
/// @param operator The operator tokens are delegated to.
/// @param extraData Data for stake delegation, as passed to
/// `receiveApproval` of `TokenStaking`.
function tryCapturingDelegationData(
Storage storage self,
TokenGrant tokenGrant,
address escrow,
address from,
address operator,
bytes memory extraData
) public returns (bool, uint256) {
if (from == escrow) {
require(extraData.length == 92, "Corrupted delegation data from escrow");
uint256 grantId = extraData.toUint(60);
setGrantForOperator(self, operator, grantId);
return (true, grantId);
} else {
return tryCapturingGrantId(self, tokenGrant, operator);
}
}
/// @notice Checks if the delegation for the given operator has been created
/// from a grant defined in the passed token grant contract and if so,
/// captures the grant ID for that delegation.
/// Grant ID can be later retrieved based on the operator address and used
/// to authenticate grantee or to fetch the information about grant
/// unlocking schedule for escrow.
/// @param tokenGrant KEEP token grant contract reference.
/// @param operator The operator tokens are delegated to.
function tryCapturingGrantId(
Storage storage self,
TokenGrant tokenGrant,
address operator
) internal returns (bool, uint256) {
(bool success, bytes memory data) = address(tokenGrant).call(
abi.encodeWithSignature("getGrantStakeDetails(address)", operator)
);
if (success) {
(uint256 grantId,,address grantStakingContract) = abi.decode(
data, (uint256, uint256, address)
);
// Double-check if the delegation in TokenGrant has been defined
// for this staking contract. If not, it means it's an old
// delegation and the current one does not come from a grant.
// The scenario covered here is:
// - grantee delegated to operator A from a TokenGrant using another
// staking contract,
// - someone delegates to operator A using liquid tokens and this
// staking contract.
// Without this check, we'd consider the second delegation as coming
// from a grant.
if (address(this) != grantStakingContract) {
return (false, 0);
}
setGrantForOperator(self, operator, grantId);
return (true, grantId);
}
return (false, 0);
}
/// @notice Returns true if the given operator operates on stake delegated
/// from a grant. false is returned otherwise.
/// @param operator The operator to which tokens from a grant are
/// potentially delegated to.
function hasGrantDelegated(
Storage storage self,
address operator
) public view returns (bool) {
return self._operatorToGrant[operator] != 0;
}
/// @notice Associates operator with the provided grant ID. It means that
/// the given operator delegates on stake from the grant with this ID.
/// @param operator The operator tokens are delegate to.
/// @param grantId Identifier of a grant from which the tokens are delegated
/// to.
function setGrantForOperator(
Storage storage self,
address operator,
uint256 grantId
) public {
self._operatorToGrant[operator] = grantId ^ GRANT_ID_FLAG;
}
/// @notice Returns grant ID for the provided operator. If the operator
/// does not operate on stake delegated from a grant, function reverts.
/// @dev To avoid reverting in case the grant ID for the operator does not
/// exist, consider calling hasGrantDelegated before.
/// @param operator The operator tokens are delegate to.
function getGrantForOperator(
Storage storage self,
address operator
) public view returns (uint256) {
uint256 grantId = self._operatorToGrant[operator];
require (grantId != 0, "No grant for the operator");
return grantId ^ GRANT_ID_FLAG;
}
/// @notice Returns true if msg.sender is grantee eligible to trigger stake
/// undelegation for this operator. Function checks both standard grantee
/// and managed grantee case.
/// @param operator The operator tokens are delegated to.
/// @param tokenGrant KEEP token grant contract reference.
function canUndelegate(
Storage storage self,
address operator,
TokenGrant tokenGrant
) public returns (bool) {
// First of all, we need to see if the operator has grant delegated.
// If not, we don't need to bother about checking grantee or
// managed grantee and we just return false.
if (!hasGrantDelegated(self, operator)) {
return false;
}
uint256 grantId = getGrantForOperator(self, operator);
(,,,,uint256 revokedAt, address grantee) = tokenGrant.getGrant(grantId);
// Is msg.sender grantee of a standard grant?
if (msg.sender == grantee) {
return true;
}
// If not, we need to dig deeper and see if we are dealing with
// a grantee from a managed grant.
if ((msg.sender).isManagedGranteeForGrant(grantId, tokenGrant)) {
return true;
}
// There is only one possibility left - grant has been revoked and
// grant manager wants to take back delegated tokens.
if (revokedAt == 0) {
return false;
}
(address grantManager,,,,) = tokenGrant.getGrantUnlockingSchedule(grantId);
return msg.sender == grantManager;
}
}
/**
โโโ โโ โโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโ โโโโโโโ โโโโโโ โโโโโโ โโโโโ โโโโโโโ โโโโโโโ
โโโโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโ โโโโโโโ โโโโโโโ
โโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโ โโโโโโโ โโโโโ โโโโโโ โโโโโ โโโโโโโ
โโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
Trust math, not hardware.
*/
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "./libraries/grant/UnlockingSchedule.sol";
import "./utils/BytesLib.sol";
import "./KeepToken.sol";
import "./utils/BytesLib.sol";
import "./TokenGrant.sol";
import "./ManagedGrant.sol";
import "./TokenSender.sol";
/// @title TokenStakingEscrow
/// @notice Escrow lets the staking contract to deposit undelegated, granted
/// tokens and either withdraw them based on the grant unlocking schedule or
/// re-delegate them to another operator.
/// @dev The owner of TokenStakingEscrow is TokenStaking contract and only owner
/// can deposit. This contract works with an assumption that operator is unique
/// in the scope of `TokenStaking`, that is, no more than one delegation in the
/// `TokenStaking` can be done do the given operator ever. Even if the previous
/// delegation ended, operator address cannot be reused.
contract TokenStakingEscrow is Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using BytesLib for bytes;
using UnlockingSchedule for uint256;
event Deposited(
address indexed operator,
uint256 indexed grantId,
uint256 amount
);
event DepositRedelegated(
address indexed previousOperator,
address indexed newOperator,
uint256 indexed grantId,
uint256 amount
);
event DepositWithdrawn(
address indexed operator,
address indexed grantee,
uint256 amount
);
event RevokedDepositWithdrawn(
address indexed operator,
address indexed grantManager,
uint256 amount
);
event EscrowAuthorized(
address indexed grantManager,
address escrow
);
IERC20 public keepToken;
TokenGrant public tokenGrant;
struct Deposit {
uint256 grantId;
uint256 amount;
uint256 withdrawn;
uint256 redelegated;
}
// operator address -> KEEP deposit
mapping(address => Deposit) internal deposits;
// Other escrows authorized by grant manager. Grantee may request to migrate
// tokens to another authorized escrow.
// grant manager -> escrow -> authorized?
mapping(address => mapping (address => bool)) internal authorizedEscrows;
constructor(
KeepToken _keepToken,
TokenGrant _tokenGrant
) public {
keepToken = _keepToken;
tokenGrant = _tokenGrant;
}
/// @notice receiveApproval accepts deposits from staking contract and
/// stores them in the escrow by the operator address from which they were
/// undelegated. Function expects operator address and grant identifier to
/// be passed as ABI-encoded information in extraData. Grant with the given
/// identifier has to exist.
/// @param from Address depositing tokens - it has to be the address of
/// TokenStaking contract owning TokenStakingEscrow.
/// @param value The amount of KEEP tokens deposited.
/// @param token The address of KEEP token contract.
/// @param extraData ABI-encoded data containing operator address (32 bytes)
/// and grant ID (32 bytes).
function receiveApproval(
address from,
uint256 value,
address token,
bytes memory extraData
) public {
require(IERC20(token) == keepToken, "Not a KEEP token");
require(msg.sender == token, "KEEP token is not the sender");
require(extraData.length == 64, "Unexpected data length");
(address operator, uint256 grantId) = abi.decode(
extraData, (address, uint256)
);
receiveDeposit(from, value, operator, grantId);
}
/// @notice Redelegates deposit or part of the deposit to another operator.
/// Uses the same staking contract as the original delegation.
/// @param previousOperator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
/// @dev Only grantee is allowed to call this function. For managed grant,
/// caller has to be the managed grantee.
/// @param amount Amount of tokens to delegate.
/// @param extraData Data for stake delegation. This byte array must have
/// the following values concatenated:
/// - Beneficiary address (20 bytes)
/// - Operator address (20 bytes)
/// - Authorizer address (20 bytes)
function redelegate(
address previousOperator,
uint256 amount,
bytes memory extraData
) public {
require(extraData.length == 60, "Corrupted delegation data");
Deposit memory deposit = deposits[previousOperator];
uint256 grantId = deposit.grantId;
address newOperator = extraData.toAddress(20);
require(isGrantee(msg.sender, grantId), "Not authorized");
require(getAmountRevoked(grantId) == 0, "Grant revoked");
require(
availableAmount(previousOperator) >= amount,
"Insufficient balance"
);
require(
!hasDeposit(newOperator),
"Redelegating to previously used operator is not allowed"
);
deposits[previousOperator].redelegated = deposit.redelegated.add(amount);
TokenSender(address(keepToken)).approveAndCall(
owner(), // TokenStaking contract associated with the escrow
amount,
abi.encodePacked(extraData, grantId)
);
emit DepositRedelegated(
previousOperator,
newOperator,
grantId,
amount
);
}
/// @notice Returns true if there is a deposit for the given operator in
/// the escrow. Otherwise, returns false.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
function hasDeposit(address operator) public view returns (bool) {
return depositedAmount(operator) > 0;
}
/// @notice Returns the currently available amount deposited in the escrow
/// that may or may not be currently withdrawable. The available amount
/// is the amount initially deposited minus the amount withdrawn and
/// redelegated so far from that deposit.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
function availableAmount(address operator) public view returns (uint256) {
Deposit memory deposit = deposits[operator];
return deposit.amount.sub(deposit.withdrawn).sub(deposit.redelegated);
}
/// @notice Returns the total amount deposited in the escrow after
/// undelegating it from the provided operator.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
function depositedAmount(address operator) public view returns (uint256) {
return deposits[operator].amount;
}
/// @notice Returns grant ID for the amount deposited in the escrow after
/// undelegating it from the provided operator.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
function depositGrantId(address operator) public view returns (uint256) {
return deposits[operator].grantId;
}
/// @notice Returns the amount withdrawn so far from the value deposited
/// in the escrow contract after undelegating it from the provided operator.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
function depositWithdrawnAmount(address operator) public view returns (uint256) {
return deposits[operator].withdrawn;
}
/// @notice Returns the total amount redelegated so far from the value
/// deposited in the escrow contract after undelegating it from the provided
/// operator.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
function depositRedelegatedAmount(address operator) public view returns (uint256) {
return deposits[operator].redelegated;
}
/// @notice Returns the currently withdrawable amount that was previously
/// deposited in the escrow after undelegating it from the provided operator.
/// Tokens are unlocked based on their grant unlocking schedule.
/// Function returns 0 for non-existing deposits and revoked grants if they
/// have been revoked before they fully unlocked.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
function withdrawable(address operator) public view returns (uint256) {
Deposit memory deposit = deposits[operator];
// Staked tokens can be only withdrawn by grantee for non-revoked grant
// assuming that grant has not fully unlocked before it's been
// revoked.
//
// It is not possible for the escrow to determine the number of tokens
// it should return to the grantee of a revoked grant given different
// possible staking contracts and staking policies.
//
// If the entire grant unlocked before it's been reverted, escrow
// lets to withdraw the entire deposited amount.
if (getAmountRevoked(deposit.grantId) == 0) {
(
uint256 duration,
uint256 start,
uint256 cliff
) = getUnlockingSchedule(deposit.grantId);
uint256 unlocked = now.getUnlockedAmount(
deposit.amount,
duration,
start,
cliff
);
if (deposit.withdrawn.add(deposit.redelegated) < unlocked) {
return unlocked.sub(deposit.withdrawn).sub(deposit.redelegated);
}
}
return 0;
}
/// @notice Withdraws currently unlocked tokens deposited in the escrow
/// after undelegating them from the provided operator. Only grantee or
/// operator can call this function. Important: this function can not be
/// called for a `ManagedGrant` grantee. This may lead to locking tokens.
/// For `ManagedGrant`, please use `withdrawToManagedGrantee` instead.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
function withdraw(address operator) public {
Deposit memory deposit = deposits[operator];
address grantee = getGrantee(deposit.grantId);
// Make sure this function is not called for a managed grant.
// If called for a managed grant, tokens could be locked there.
// Better be safe than sorry.
(bool success, ) = address(this).call(
abi.encodeWithSignature("getManagedGrantee(address)", grantee)
);
require(!success, "Can not be called for managed grant");
require(
msg.sender == grantee || msg.sender == operator,
"Only grantee or operator can withdraw"
);
withdraw(deposit, operator, grantee);
}
/// @notice Withdraws currently unlocked tokens deposited in the escrow
/// after undelegating them from the provided operator. Only grantee or
/// operator can call this function. This function works only for
/// `ManagedGrant` grantees. For a standard grant, please use `withdraw`
/// instead.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
function withdrawToManagedGrantee(address operator) public {
Deposit memory deposit = deposits[operator];
address managedGrant = getGrantee(deposit.grantId);
address grantee = getManagedGrantee(managedGrant);
require(
msg.sender == grantee || msg.sender == operator,
"Only grantee or operator can withdraw"
);
withdraw(deposit, operator, grantee);
}
/// @notice Migrates all available tokens to another authorized escrow.
/// Can be requested only by grantee.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
/// @param receivingEscrow Escrow to which tokens should be migrated.
/// @dev The receiving escrow needs to accept deposits from this escrow, at
/// least for the period of migration.
function migrate(
address operator,
address receivingEscrow
) public {
Deposit memory deposit = deposits[operator];
require(isGrantee(msg.sender, deposit.grantId), "Not authorized");
address grantManager = getGrantManager(deposit.grantId);
require(
authorizedEscrows[grantManager][receivingEscrow],
"Escrow not authorized"
);
uint256 amountLeft = availableAmount(operator);
deposits[operator].withdrawn = deposit.withdrawn.add(amountLeft);
TokenSender(address(keepToken)).approveAndCall(
receivingEscrow,
amountLeft,
abi.encode(operator, deposit.grantId)
);
}
/// @notice Withdraws the entire amount that is still deposited in the
/// escrow in case the grant has been revoked. Anyone can call this function
/// and the entire amount is transferred back to the grant manager.
/// @param operator Address of the operator from the undelegated/canceled
/// delegation from which tokens were deposited.
function withdrawRevoked(address operator) public {
Deposit memory deposit = deposits[operator];
require(
getAmountRevoked(deposit.grantId) > 0,
"No revoked tokens to withdraw"
);
address grantManager = getGrantManager(deposit.grantId);
withdrawRevoked(deposit, operator, grantManager);
}
/// @notice Used by grant manager to authorize another escrows for
// funds migration.
function authorizeEscrow(address anotherEscrow) public {
require(
anotherEscrow != address(0x0),
"Escrow address can't be zero"
);
authorizedEscrows[msg.sender][anotherEscrow] = true;
emit EscrowAuthorized(msg.sender, anotherEscrow);
}
/// @notice Resolves the final grantee of ManagedGrant contract. If the
/// provided address is not a ManagedGrant contract, function reverts.
/// @param managedGrant Address of the managed grant contract.
function getManagedGrantee(
address managedGrant
) public view returns(address) {
ManagedGrant grant = ManagedGrant(managedGrant);
return grant.grantee();
}
function receiveDeposit(
address from,
uint256 value,
address operator,
uint256 grantId
) internal {
// This contract works with an assumption that operator is unique.
// This is fine as long as the staking contract works with the same
// assumption so we are limiting deposits to the staking contract only.
require(from == owner(), "Only owner can deposit");
require(
getAmountGranted(grantId) > 0,
"Grant with this ID does not exist"
);
require(
!hasDeposit(operator),
"Stake for the operator already deposited in the escrow"
);
keepToken.safeTransferFrom(from, address(this), value);
deposits[operator] = Deposit(grantId, value, 0, 0);
emit Deposited(operator, grantId, value);
}
function isGrantee(
address maybeGrantee,
uint256 grantId
) internal returns (bool) {
// Let's check the simplest case first - standard grantee.
// If the given address is set as a grantee for grant with the given ID,
// we return true.
address grantee = getGrantee(grantId);
if (maybeGrantee == grantee) {
return true;
}
// If the given address is not a standard grantee, there is still
// a chance that address is a managed grantee. We are calling
// getManagedGrantee that will cast the grantee to ManagedGrant and try
// to call getGrantee() function. If this call returns non-zero address,
// it means we are dealing with a ManagedGrant.
(, bytes memory result) = address(this).call(
abi.encodeWithSignature("getManagedGrantee(address)", grantee)
);
if (result.length == 0) {
return false;
}
// At this point we know we are dealing with a ManagedGrant, so the last
// thing we need to check is whether the managed grantee of that grant
// is the grantee address passed as a parameter.
address managedGrantee = abi.decode(result, (address));
return maybeGrantee == managedGrantee;
}
function withdraw(
Deposit memory deposit,
address operator,
address grantee
) internal {
uint256 amount = withdrawable(operator);
deposits[operator].withdrawn = deposit.withdrawn.add(amount);
keepToken.safeTransfer(grantee, amount);
emit DepositWithdrawn(operator, grantee, amount);
}
function withdrawRevoked(
Deposit memory deposit,
address operator,
address grantManager
) internal {
uint256 amount = availableAmount(operator);
deposits[operator].withdrawn = amount;
keepToken.safeTransfer(grantManager, amount);
emit RevokedDepositWithdrawn(operator, grantManager, amount);
}
function getAmountGranted(uint256 grantId) internal view returns (
uint256 amountGranted
) {
(amountGranted,,,,,) = tokenGrant.getGrant(grantId);
}
function getAmountRevoked(uint256 grantId) internal view returns (
uint256 amountRevoked
) {
(,,,amountRevoked,,) = tokenGrant.getGrant(grantId);
}
function getUnlockingSchedule(uint256 grantId) internal view returns (
uint256 duration,
uint256 start,
uint256 cliff
) {
(,duration,start,cliff,) = tokenGrant.getGrantUnlockingSchedule(grantId);
}
function getGrantee(uint256 grantId) internal view returns (
address grantee
) {
(,,,,,grantee) = tokenGrant.getGrant(grantId);
}
function getGrantManager(uint256 grantId) internal view returns (
address grantManager
) {
(grantManager,,,,) = tokenGrant.getGrantUnlockingSchedule(grantId);
}
}
pragma solidity ^0.5.4;
import "openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol";
import "./TokenGrant.sol";
/// @title ManagedGrant
/// @notice A managed grant acts as the grantee towards the token grant contract,
/// proxying instructions from the actual grantee.
/// The address used by the actual grantee
/// to issue instructions and withdraw tokens
/// can be reassigned with the consent of the grant manager.
contract ManagedGrant {
using SafeERC20 for ERC20Burnable;
ERC20Burnable public token;
TokenGrant public tokenGrant;
address public grantManager;
uint256 public grantId;
address public grantee;
address public requestedNewGrantee;
event GranteeReassignmentRequested(
address newGrantee
);
event GranteeReassignmentConfirmed(
address oldGrantee,
address newGrantee
);
event GranteeReassignmentCancelled(
address cancelledRequestedGrantee
);
event GranteeReassignmentChanged(
address previouslyRequestedGrantee,
address newRequestedGrantee
);
event TokensWithdrawn(
address destination,
uint256 amount
);
constructor(
address _tokenAddress,
address _tokenGrant,
address _grantManager,
uint256 _grantId,
address _grantee
) public {
token = ERC20Burnable(_tokenAddress);
tokenGrant = TokenGrant(_tokenGrant);
grantManager = _grantManager;
grantId = _grantId;
grantee = _grantee;
}
/// @notice Request a reassignment of the grantee address.
/// Can only be called by the grantee.
/// @param _newGrantee The requested new grantee.
function requestGranteeReassignment(address _newGrantee)
public
onlyGrantee
noRequestedReassignment
{
_setRequestedNewGrantee(_newGrantee);
emit GranteeReassignmentRequested(_newGrantee);
}
/// @notice Cancel a pending grantee reassignment request.
/// Can only be called by the grantee.
function cancelReassignmentRequest()
public
onlyGrantee
withRequestedReassignment
{
address cancelledGrantee = requestedNewGrantee;
requestedNewGrantee = address(0);
emit GranteeReassignmentCancelled(cancelledGrantee);
}
/// @notice Change a pending reassignment request to a different grantee.
/// Can only be called by the grantee.
/// @param _newGrantee The address of the new requested grantee.
function changeReassignmentRequest(address _newGrantee)
public
onlyGrantee
withRequestedReassignment
{
address previouslyRequestedGrantee = requestedNewGrantee;
require(
previouslyRequestedGrantee != _newGrantee,
"Unchanged reassignment request"
);
_setRequestedNewGrantee(_newGrantee);
emit GranteeReassignmentChanged(previouslyRequestedGrantee, _newGrantee);
}
/// @notice Confirm a grantee reassignment request and set the new grantee as the grantee.
/// Can only be called by the grant manager.
/// @param _newGrantee The address of the new grantee.
/// Must match the currently requested new grantee.
function confirmGranteeReassignment(address _newGrantee)
public
onlyManager
withRequestedReassignment
{
address oldGrantee = grantee;
require(
requestedNewGrantee == _newGrantee,
"Reassignment address mismatch"
);
grantee = requestedNewGrantee;
requestedNewGrantee = address(0);
emit GranteeReassignmentConfirmed(oldGrantee, _newGrantee);
}
/// @notice Withdraw all unlocked tokens from the grant.
function withdraw() public onlyGrantee {
require(
requestedNewGrantee == address(0),
"Can not withdraw with pending reassignment"
);
tokenGrant.withdraw(grantId);
uint256 amount = token.balanceOf(address(this));
token.safeTransfer(grantee, amount);
emit TokensWithdrawn(grantee, amount);
}
/// @notice Stake tokens from the grant.
/// @param _stakingContract The contract to stake the tokens on.
/// @param _amount The amount of tokens to stake.
/// @param _extraData Data for the stake delegation.
/// This byte array must have the following values concatenated:
/// beneficiary address (20 bytes)
/// operator address (20 bytes)
/// authorizer address (20 bytes)
function stake(
address _stakingContract,
uint256 _amount,
bytes memory _extraData
) public onlyGrantee {
tokenGrant.stake(grantId, _stakingContract, _amount, _extraData);
}
/// @notice Cancel delegating tokens to the given operator.
function cancelStake(address _operator) public onlyGranteeOr(_operator) {
tokenGrant.cancelStake(_operator);
}
/// @notice Begin undelegating tokens from the given operator.
function undelegate(address _operator) public onlyGranteeOr(_operator) {
tokenGrant.undelegate(_operator);
}
/// @notice Recover tokens previously staked and delegated to the operator.
function recoverStake(address _operator) public {
tokenGrant.recoverStake(_operator);
}
function _setRequestedNewGrantee(address _newGrantee) internal {
require(_newGrantee != address(0), "Invalid new grantee address");
require(_newGrantee != grantee, "New grantee same as current grantee");
requestedNewGrantee = _newGrantee;
}
modifier withRequestedReassignment {
require(
requestedNewGrantee != address(0),
"No reassignment requested"
);
_;
}
modifier noRequestedReassignment {
require(
requestedNewGrantee == address(0),
"Reassignment already requested"
);
_;
}
modifier onlyGrantee {
require(
msg.sender == grantee,
"Only grantee may perform this action"
);
_;
}
modifier onlyGranteeOr(address _operator) {
require(
msg.sender == grantee || msg.sender == _operator,
"Only grantee or operator may perform this action"
);
_;
}
modifier onlyManager {
require(
msg.sender == grantManager,
"Only grantManager may perform this action"
);
_;
}
}
pragma solidity 0.5.17;
/// @dev Interface of sender contract for approveAndCall pattern.
interface TokenSender {
function approveAndCall(address _spender, uint256 _value, bytes calldata _extraData) external;
}
pragma solidity 0.5.17;
import "../utils/AddressArrayUtils.sol";
import "../StakeDelegatable.sol";
import "../TokenGrant.sol";
import "../ManagedGrant.sol";
/// @title Roles Lookup
/// @notice Library facilitating lookup of roles in stake delegation setup.
library RolesLookup {
using AddressArrayUtils for address[];
/// @notice Returns true if the tokenOwner delegated tokens to operator
/// using the provided stakeDelegatable contract. Othwerwise, returns false.
/// This function works only for the case when tokenOwner own those tokens
/// and those are not tokens from a grant.
function isTokenOwnerForOperator(
address tokenOwner,
address operator,
StakeDelegatable stakeDelegatable
) internal view returns (bool) {
return stakeDelegatable.ownerOf(operator) == tokenOwner;
}
/// @notice Returns true if the grantee delegated tokens to operator
/// with the provided tokenGrant contract. Otherwise, returns false.
/// This function works only for the case when tokens were generated from
/// a non-managed grant, that is, the grantee is a non-contract address to
/// which the delegated tokens were granted.
/// @dev This function does not validate the staking reltionship on
/// a particular staking contract. It only checks whether the grantee
/// staked at least one time with the given operator. If you are interested
/// in a particular token staking contract, you need to perform additional
/// check.
function isGranteeForOperator(
address grantee,
address operator,
TokenGrant tokenGrant
) internal view returns (bool) {
address[] memory operators = tokenGrant.getGranteeOperators(grantee);
return operators.contains(operator);
}
/// @notice Returns true if the grantee from the given managed grant contract
/// delegated tokens to operator with the provided tokenGrant contract.
/// Otherwise, returns false. In case the grantee declared by the managed
/// grant contract does not match the provided grantee, function reverts.
/// This function works only for cases when grantee, from TokenGrant's
/// perspective, is a smart contract exposing grantee() function returning
/// the final grantee. One possibility is the ManagedGrant contract.
/// @dev This function does not validate the staking reltionship on
/// a particular staking contract. It only checks whether the grantee
/// staked at least one time with the given operator. If you are interested
/// in a particular token staking contract, you need to perform additional
/// check.
function isManagedGranteeForOperator(
address grantee,
address operator,
address managedGrantContract,
TokenGrant tokenGrant
) internal view returns (bool) {
require(
ManagedGrant(managedGrantContract).grantee() == grantee,
"Not a grantee of the provided contract"
);
address[] memory operators = tokenGrant.getGranteeOperators(
managedGrantContract
);
return operators.contains(operator);
}
/// @notice Returns true if grant with the given ID has been created with
/// managed grant pointing currently to the grantee passed as a parameter.
/// @dev The function does not revert if grant has not been created with
/// a managed grantee. This function is not a view because it uses low-level
/// call to check if the grant has been created with a managed grant.
/// It does not however modify any state.
function isManagedGranteeForGrant(
address grantee,
uint256 grantId,
TokenGrant tokenGrant
) internal returns (bool) {
(,,,,, address managedGrant) = tokenGrant.getGrant(grantId);
(, bytes memory result) = managedGrant.call(
abi.encodeWithSignature("grantee()")
);
if (result.length == 0) {
return false;
}
address managedGrantee = abi.decode(result, (address));
return grantee == managedGrantee;
}
}
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import { AuthorityVerifier } from "../../Authorizations.sol";
import "./LockUtils.sol";
library Locks {
using SafeMath for uint256;
using LockUtils for LockUtils.LockSet;
event StakeLocked(address indexed operator, address lockCreator, uint256 until);
event LockReleased(address indexed operator, address lockCreator);
event ExpiredLockReleased(address indexed operator, address lockCreator);
uint256 public constant maximumLockDuration = 86400 * 200; // 200 days in seconds
struct Storage {
// Locks placed on the operator.
// `operatorLocks[operator]` returns all locks placed on the operator.
// Each authorized operator contract can place one lock on an operator.
mapping(address => LockUtils.LockSet) operatorLocks;
}
function lockStake(
Storage storage self,
address operator,
uint256 duration
) public {
require(duration <= maximumLockDuration, "Lock duration too long");
self.operatorLocks[operator].setLock(
msg.sender,
uint96(block.timestamp.add(duration))
);
emit StakeLocked(operator, msg.sender, block.timestamp.add(duration));
}
function releaseLock(
Storage storage self,
address operator
) public {
self.operatorLocks[operator].releaseLock(msg.sender);
emit LockReleased(operator, msg.sender);
}
function releaseExpiredLock(
Storage storage self,
address operator,
address operatorContract,
address authorityVerifier
) public {
LockUtils.LockSet storage locks = self.operatorLocks[operator];
require(
locks.contains(operatorContract),
"No matching lock present"
);
bool expired = block.timestamp >= locks.getLockTime(operatorContract);
bool disabled = !AuthorityVerifier(authorityVerifier)
.isApprovedOperatorContract(operatorContract);
require(
expired || disabled,
"Lock still active and valid"
);
locks.releaseLock(operatorContract);
emit ExpiredLockReleased(operator, operatorContract);
}
/// @dev AuthorityVerifier is a trusted implementation and not a third-party,
/// external contract. AuthorityVerifier never reverts on the check and
/// has a reasonable gas consumption.
function isStakeLocked(
Storage storage self,
address operator,
address authorityVerifier
) public view returns (bool) {
LockUtils.Lock[] storage _locks = self.operatorLocks[operator].locks;
LockUtils.Lock memory lock;
for (uint i = 0; i < _locks.length; i++) {
lock = _locks[i];
if (block.timestamp < lock.expiresAt) {
if (
AuthorityVerifier(authorityVerifier)
.isApprovedOperatorContract(lock.creator)
) {
return true;
}
}
}
return false;
}
function isStakeReleased(
Storage storage self,
address operator,
address operatorContract
) public view returns (bool) {
LockUtils.LockSet storage locks = self.operatorLocks[operator];
// `getLockTime` returns 0 if the lock doesn't exist,
// thus we don't need to check for its presence separately.
return block.timestamp >= locks.getLockTime(operatorContract);
}
function getLocks(
Storage storage self,
address operator
) public view returns (address[] memory creators, uint256[] memory expirations) {
uint256 lockCount = self.operatorLocks[operator].locks.length;
creators = new address[](lockCount);
expirations = new uint256[](lockCount);
LockUtils.Lock memory lock;
for (uint i = 0; i < lockCount; i++) {
lock = self.operatorLocks[operator].locks[i];
creators[i] = lock.creator;
expirations[i] = lock.expiresAt;
}
}
}
/**
โโโ โโ โโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโ โโโโโโโ โโโโโโ โโโโโโ โโโโโ โโโโโโโ โโโโโโโ
โโโโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโ โโโโโโโ โโโโโโโ
โโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโ โโโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโ โโโโโโโ โโโโโ โโโโโโ โโโโโ โโโโโโโ
โโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
Trust math, not hardware.
*/
pragma solidity 0.5.17;
import "./KeepRegistry.sol";
/// @title AuthorityDelegator
/// @notice An operator contract can delegate authority to other operator
/// contracts by implementing the AuthorityDelegator interface.
///
/// To delegate authority,
/// the recipient of delegated authority must call `claimDelegatedAuthority`,
/// specifying the contract it wants delegated authority from.
/// The staking contract calls `delegator.__isRecognized(recipient)`
/// and if the call returns `true`,
/// the named delegator contract is set as the recipient's authority delegator.
/// Any future checks of registry approval or per-operator authorization
/// will transparently mirror the delegator's status.
///
/// Authority can be delegated recursively;
/// an operator contract receiving delegated authority
/// can recognize other operator contracts as recipients of its authority.
interface AuthorityDelegator {
function __isRecognized(address delegatedAuthorityRecipient) external returns (bool);
}
/// @title AuthorityVerifier
/// @notice An operator contract can delegate authority to other operator
/// contracts. Entry in the registry is not updated and source contract remains
/// listed there as authorized. This interface is a verifier that support verification
/// of contract authorization in case of authority delegation from the source contract.
interface AuthorityVerifier {
/// @notice Returns true if the given operator contract has been approved
/// for use. The function never reverts.
function isApprovedOperatorContract(address _operatorContract)
external
view
returns (bool);
}
contract Authorizations is AuthorityVerifier {
// Authorized operator contracts.
mapping(address => mapping (address => bool)) internal authorizations;
// Granters of delegated authority to operator contracts.
// E.g. keep factories granting delegated authority to keeps.
// `delegatedAuthority[keep] = factory`
mapping(address => address) internal delegatedAuthority;
// Registry contract with a list of approved operator contracts and upgraders.
KeepRegistry internal registry;
modifier onlyApprovedOperatorContract(address operatorContract) {
require(
isApprovedOperatorContract(operatorContract),
"Operator contract unapproved"
);
_;
}
constructor(KeepRegistry _registry) public {
registry = _registry;
}
/// @notice Gets the authorizer for the specified operator address.
/// @return Authorizer address.
function authorizerOf(address _operator) public view returns (address);
/// @notice Authorizes operator contract to access staked token balance of
/// the provided operator. Can only be executed by stake operator authorizer.
/// Contracts using delegated authority
/// cannot be authorized with `authorizeOperatorContract`.
/// Instead, authorize `getAuthoritySource(_operatorContract)`.
/// @param _operator address of stake operator.
/// @param _operatorContract address of operator contract.
function authorizeOperatorContract(address _operator, address _operatorContract)
public
onlyApprovedOperatorContract(_operatorContract) {
require(
authorizerOf(_operator) == msg.sender,
"Not operator authorizer"
);
require(
getAuthoritySource(_operatorContract) == _operatorContract,
"Delegated authority used"
);
authorizations[_operatorContract][_operator] = true;
}
/// @notice Checks if operator contract has access to the staked token balance of
/// the provided operator.
/// @param _operator address of stake operator.
/// @param _operatorContract address of operator contract.
function isAuthorizedForOperator(
address _operator,
address _operatorContract
) public view returns (bool) {
return authorizations[getAuthoritySource(_operatorContract)][_operator];
}
/// @notice Grant the sender the same authority as `delegatedAuthoritySource`
/// @dev If `delegatedAuthoritySource` is an approved operator contract
/// and recognizes the claimant, this relationship will be recorded in
/// `delegatedAuthority`. Later, the claimant can slash, seize, place locks etc.
/// on operators that have authorized the `delegatedAuthoritySource`.
/// If the `delegatedAuthoritySource` is disabled with the panic button,
/// any recipients of delegated authority from it will also be disabled.
function claimDelegatedAuthority(
address delegatedAuthoritySource
) public onlyApprovedOperatorContract(delegatedAuthoritySource) {
require(
AuthorityDelegator(delegatedAuthoritySource).__isRecognized(msg.sender),
"Unrecognized claimant"
);
delegatedAuthority[msg.sender] = delegatedAuthoritySource;
}
/// @notice Checks if the operator contract is authorized in the registry.
/// If the contract uses delegated authority it checks authorization of the
/// source contract.
/// @param _operatorContract address of operator contract.
/// @return True if operator contract is approved, false if operator contract
/// has not been approved or if it was disabled by the panic button.
function isApprovedOperatorContract(address _operatorContract)
public
view
returns (bool)
{
return
registry.isApprovedOperatorContract(
getAuthoritySource(_operatorContract)
);
}
/// @notice Get the source of the operator contract's authority.
/// If the contract uses delegated authority,
/// returns the original source of the delegated authority.
/// If the contract doesn't use delegated authority,
/// returns the contract itself.
/// Authorize `getAuthoritySource(operatorContract)`
/// to grant `operatorContract` the authority to penalize an operator.
function getAuthoritySource(
address operatorContract
) public view returns (address) {
address delegatedAuthoritySource = delegatedAuthority[operatorContract];
if (delegatedAuthoritySource == address(0)) {
return operatorContract;
}
return getAuthoritySource(delegatedAuthoritySource);
}
}
pragma solidity 0.5.17;
library LockUtils {
struct Lock {
address creator;
uint96 expiresAt;
}
/// @notice The LockSet is like an array of unique `uint256`s,
/// but additionally supports O(1) membership tests and removals.
/// @dev Because the LockSet relies on a mapping,
/// it can only be used in storage, not in memory.
struct LockSet {
// locks[positions[lock.creator] - 1] = lock
Lock[] locks;
mapping(address => uint256) positions;
}
/// @notice Check whether the LockSet `self` contains a lock by `creator`
function contains(LockSet storage self, address creator)
internal view returns (bool) {
return (self.positions[creator] != 0);
}
function getLockTime(LockSet storage self, address creator)
internal view returns (uint96) {
uint256 positionPlusOne = self.positions[creator];
if (positionPlusOne == 0) { return 0; }
return self.locks[positionPlusOne - 1].expiresAt;
}
/// @notice Set the lock of `creator` to `expiresAt`,
/// overriding the current value if any.
function setLock(
LockSet storage self,
address _creator,
uint96 _expiresAt
) internal {
uint256 positionPlusOne = self.positions[_creator];
Lock memory lock = Lock(_creator, _expiresAt);
// No existing lock
if (positionPlusOne == 0) {
self.locks.push(lock);
self.positions[_creator] = self.locks.length;
// Existing lock present
} else {
self.locks[positionPlusOne - 1].expiresAt = _expiresAt;
}
}
/// @notice Remove the lock of `creator`.
/// If no lock present, do nothing.
function releaseLock(
LockSet storage self,
address _creator
) internal {
uint256 positionPlusOne = self.positions[_creator];
if (positionPlusOne != 0) {
uint256 lockCount = self.locks.length;
if (positionPlusOne != lockCount) {
// Not the last lock,
// so we need to move the last lock into the emptied position.
Lock memory lastLock = self.locks[lockCount - 1];
self.locks[positionPlusOne - 1] = lastLock;
self.positions[lastLock.creator] = positionPlusOne;
}
self.locks.length--;
self.positions[_creator] = 0;
}
}
/// @notice Return the locks of the LockSet `self`.
function enumerate(LockSet storage self)
internal view returns (Lock[] memory) {
return self.locks;
}
}
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "../../TokenStakingEscrow.sol";
import "../../utils/OperatorParams.sol";
/// @notice TokenStaking contract library allowing to perform two-step stake
/// top-ups for existing delegations.
/// Top-up is a two-step process: it is initiated with a declared top-up value
/// and after waiting for at least the initialization period it can be
/// committed.
library TopUps {
using SafeMath for uint256;
using OperatorParams for uint256;
event TopUpInitiated(address indexed operator, uint256 topUp);
event TopUpCompleted(address indexed operator, uint256 newAmount);
struct TopUp {
uint256 amount;
uint256 createdAt;
}
struct Storage {
// operator -> TopUp
mapping(address => TopUp) topUps;
}
/// @notice Performs top-up in one step when stake is not yet initialized by
/// adding the top-up amount to the stake and resetting stake initialization
/// time counter.
/// @dev This function should be called only for not yet initialized stake.
/// @param value Top-up value, the number of tokens added to the stake.
/// @param operator Operator The operator with existing delegation to which
/// the tokens should be added to.
/// @param operatorParams Parameters of that operator, as stored in the
/// staking contract.
/// @param escrow Reference to TokenStakingEscrow contract.
/// @return New value of parameters. It should be updated for the operator
/// in the staking contract.
function instantComplete(
Storage storage self,
uint256 value,
address operator,
uint256 operatorParams,
TokenStakingEscrow escrow
) public returns (uint256 newParams) {
// Stake is not yet initialized so we don't need to check if the
// operator is not undelegating - initializing and undelegating at the
// same time is not possible. We do however, need to check whether the
// operator has not canceled its previous stake for that operator,
// depositing the stake it in the escrow. We do not want to allow
// resurrecting operators with cancelled stake by top-ups.
require(
!escrow.hasDeposit(operator),
"Stake for the operator already deposited in the escrow"
);
require(value > 0, "Top-up value must be greater than zero");
uint256 newAmount = operatorParams.getAmount().add(value);
newParams = operatorParams.setAmountAndCreationTimestamp(
newAmount,
block.timestamp
);
emit TopUpCompleted(operator, newAmount);
}
/// @notice Initiates top-up of the given value for tokens delegated to
/// the provided operator. If there is an existing top-up still
/// initializing, top-up values are summed up and initialization period
/// is set to the current block timestamp.
/// @dev This function should be called only for active operators with
/// initialized stake.
/// @param value Top-up value, the number of tokens added to the stake.
/// @param operator Operator The operator with existing delegation to which
/// the tokens should be added to.
/// @param operatorParams Parameters of that operator, as stored in the
/// staking contract.
/// @param escrow Reference to TokenStakingEscrow contract.
function initiate(
Storage storage self,
uint256 value,
address operator,
uint256 operatorParams,
TokenStakingEscrow escrow
) public {
// Stake is initialized, the operator is still active so we need
// to check if it's not undelegating.
require(!isUndelegating(operatorParams), "Stake undelegated");
// We also need to check if the stake for the operator is not already
// in the escrow because it's been previously cancelled.
require(
!escrow.hasDeposit(operator),
"Stake for the operator already deposited in the escrow"
);
require(value > 0, "Top-up value must be greater than zero");
TopUp memory awaiting = self.topUps[operator];
self.topUps[operator] = TopUp(awaiting.amount.add(value), now);
emit TopUpInitiated(operator, value);
}
/// @notice Commits the top-up if it passed the initialization period.
/// Tokens are added to the stake once the top-up is committed.
/// @param operator Operator The operator with a pending stake top-up.
/// @param initializationPeriod Stake initialization period.
function commit(
Storage storage self,
address operator,
uint256 operatorParams,
uint256 initializationPeriod
) public returns (uint256 newParams) {
TopUp memory topUp = self.topUps[operator];
require(topUp.amount > 0, "No top up to commit");
require(
now > topUp.createdAt.add(initializationPeriod),
"Stake is initializing"
);
uint256 newAmount = operatorParams.getAmount().add(topUp.amount);
newParams = operatorParams.setAmount(newAmount);
delete self.topUps[operator];
emit TopUpCompleted(operator, newAmount);
}
/// @notice Cancels pending, initiating top-up. If there is no initiating
/// top-up for the operator, function does nothing. This function should be
/// used when the stake is recovered to return tokens from a pending,
/// initiating top-up.
/// @param operator Operator The operator from which the stake is recovered.
function cancel(
Storage storage self,
address operator
) public returns (uint256) {
TopUp memory topUp = self.topUps[operator];
if (topUp.amount == 0) {
return 0;
}
delete self.topUps[operator];
return topUp.amount;
}
/// @notice Returns true if the given operatorParams indicate that the
/// operator is undelegating its stake or that it completed stake
/// undelegation.
/// @param operatorParams Parameters of the operator, as stored in the
/// staking contract.
function isUndelegating(uint256 operatorParams)
internal view returns (bool) {
uint256 undelegatedAt = operatorParams.getUndelegationTimestamp();
return (undelegatedAt != 0) && (block.timestamp > undelegatedAt);
}
}
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
library PercentUtils {
using SafeMath for uint256;
// Return `b`% of `a`
// 200.percent(40) == 80
// Commutative, works both ways
function percent(uint256 a, uint256 b) internal pure returns (uint256) {
return a.mul(b).div(100);
}
// Return `a` as percentage of `b`:
// 80.asPercentOf(200) == 40
function asPercentOf(uint256 a, uint256 b) internal pure returns (uint256) {
return a.mul(100).div(b);
}
}
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "./TokenStaking.sol";
import "./TokenSender.sol";
import "./utils/BytesLib.sol";
/// @dev Interface of sender contract for approveAndCall pattern.
interface tokenSender {
function approveAndCall(address _spender, uint256 _value, bytes calldata _extraData) external;
}
contract TokenGrantStake {
using SafeMath for uint256;
using BytesLib for bytes;
ERC20Burnable token;
TokenStaking tokenStaking;
address tokenGrant; // Address of the master grant contract.
uint256 grantId; // ID of the grant for this stake.
uint256 amount; // Amount of staked tokens.
address operator; // Operator of the stake.
constructor(
address _tokenAddress,
uint256 _grantId,
address _tokenStaking
) public {
require(
_tokenAddress != address(0x0),
"Token address can't be zero."
);
require(
_tokenStaking != address(0x0),
"Staking contract address can't be zero."
);
token = ERC20Burnable(_tokenAddress);
tokenGrant = msg.sender;
grantId = _grantId;
tokenStaking = TokenStaking(_tokenStaking);
}
function stake(
uint256 _amount,
bytes memory _extraData
) public onlyGrant {
amount = _amount;
operator = _extraData.toAddress(20);
tokenSender(address(token)).approveAndCall(
address(tokenStaking),
_amount,
_extraData
);
}
function getGrantId() public view onlyGrant returns (uint256) {
return grantId;
}
function getAmount() public view onlyGrant returns (uint256) {
return amount;
}
function getStakingContract() public view onlyGrant returns (address) {
return address(tokenStaking);
}
function getDetails() public view onlyGrant returns (
uint256 _grantId,
uint256 _amount,
address _tokenStaking
) {
return (
grantId,
amount,
address(tokenStaking)
);
}
function cancelStake() public onlyGrant returns (uint256) {
tokenStaking.cancelStake(operator);
return returnTokens();
}
function undelegate() public onlyGrant {
tokenStaking.undelegate(operator);
}
function recoverStake() public onlyGrant returns (uint256) {
tokenStaking.recoverStake(operator);
return returnTokens();
}
function returnTokens() internal returns (uint256) {
uint256 returnedAmount = token.balanceOf(address(this));
amount -= returnedAmount;
token.transfer(tokenGrant, returnedAmount);
return returnedAmount;
}
modifier onlyGrant {
require(
msg.sender == tokenGrant,
"For token grant contract only"
);
_;
}
}
pragma solidity 0.5.17;
/// @title GrantStakingPolicy
/// @notice A staking policy defines the function `getStakeableAmount`
/// which calculates how many tokens may be staked from a token grant.
contract GrantStakingPolicy {
function getStakeableAmount(
uint256 _now,
uint256 grantedAmount,
uint256 duration,
uint256 start,
uint256 cliff,
uint256 withdrawn) public view returns (uint256);
}
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
library UnlockingSchedule {
using SafeMath for uint256;
function getUnlockedAmount(
uint256 _now,
uint256 grantedAmount,
uint256 duration,
uint256 start,
uint256 cliff
) internal pure returns (uint256) {
bool cliffNotReached = _now < cliff;
if (cliffNotReached) { return 0; }
uint256 timeElapsed = _now.sub(start);
bool unlockingPeriodFinished = timeElapsed >= duration;
if (unlockingPeriodFinished) { return grantedAmount; }
return grantedAmount.mul(timeElapsed).div(duration);
}
}
pragma solidity 0.5.17;
/*
Verison pulled from https://github.com/summa-tx/bitcoin-spv/blob/2535e4edaeaac4b2b095903fce684ae1c05761bc/solidity/contracts/BytesLib.sol
*/
/*
https://github.com/GNSPS/solidity-bytes-utils/
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.
In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
For more information, please refer to <https://unlicense.org>
*/
/** @title BytesLib **/
/** @author https://github.com/GNSPS **/
library BytesLib {
function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes memory) {
bytes memory tempBytes;
assembly {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// Store the length of the first bytes array at the beginning of
// the memory for tempBytes.
let length := mload(_preBytes)
mstore(tempBytes, length)
// Maintain a memory counter for the current write location in the
// temp bytes array by adding the 32 bytes for the array length to
// the starting location.
let mc := add(tempBytes, 0x20)
// Stop copying when the memory counter reaches the length of the
// first bytes array.
let end := add(mc, length)
for {
// Initialize a copy counter to the start of the _preBytes data,
// 32 bytes into its memory.
let cc := add(_preBytes, 0x20)
} lt(mc, end) {
// Increase both counters by 32 bytes each iteration.
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
// Write the _preBytes data into the tempBytes memory 32 bytes
// at a time.
mstore(mc, mload(cc))
}
// Add the length of _postBytes to the current length of tempBytes
// and store it as the new length in the first 32 bytes of the
// tempBytes memory.
length := mload(_postBytes)
mstore(tempBytes, add(length, mload(tempBytes)))
// Move the memory counter back from a multiple of 0x20 to the
// actual end of the _preBytes data.
mc := end
// Stop copying when the memory counter reaches the new combined
// length of the arrays.
end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
// Update the free-memory pointer by padding our last write location
// to 32 bytes: add 31 bytes to the end of tempBytes to move to the
// next 32 byte block, then round down to the nearest multiple of
// 32. If the sum of the length of the two arrays is zero then add
// one before rounding down to leave a blank 32 bytes (the length block with 0).
mstore(0x40, and(
add(add(end, iszero(add(length, mload(_preBytes)))), 31),
not(31) // Round down to the nearest 32 bytes.
))
}
return tempBytes;
}
function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
assembly {
// Read the first 32 bytes of _preBytes storage, which is the length
// of the array. (We don't need to use the offset into the slot
// because arrays use the entire slot.)
let fslot := sload(_preBytes_slot)
// Arrays of 31 bytes or less have an even value in their slot,
// while longer arrays have an odd value. The actual length is
// the slot divided by two for odd values, and the lowest order
// byte divided by two for even values.
// If the slot is even, bitwise and the slot with 255 and divide by
// two to get the length. If the slot is odd, bitwise and the slot
// with -1 and divide by two.
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
let newlength := add(slength, mlength)
// slength can contain both the length and contents of the array
// if length < 32 bytes so let's prepare for that
// v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
switch add(lt(slength, 32), lt(newlength, 32))
case 2 {
// Since the new array still fits in the slot, we just need to
// update the contents of the slot.
// uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
sstore(
_preBytes_slot,
// all the modifications to the slot are inside this
// next block
add(
// we can just add to the slot contents because the
// bytes we want to change are the LSBs
fslot,
add(
mul(
div(
// load the bytes from memory
mload(add(_postBytes, 0x20)),
// zero all bytes to the right
exp(0x100, sub(32, mlength))
),
// and now shift left the number of bytes to
// leave space for the length in the slot
exp(0x100, sub(32, newlength))
),
// increase length by the double of the memory
// bytes length
mul(mlength, 2)
)
)
)
}
case 1 {
// The stored value fits in the slot, but the combined value
// will exceed it.
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes_slot)
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
// save new length
sstore(_preBytes_slot, add(mul(newlength, 2), 1))
// The contents of the _postBytes array start 32 bytes into
// the structure. Our first read should obtain the `submod`
// bytes that can fit into the unused space in the last word
// of the stored array. To get this, we read 32 bytes starting
// from `submod`, so the data we read overlaps with the array
// contents by `submod` bytes. Masking the lowest-order
// `submod` bytes allows us to add that value directly to the
// stored value.
let submod := sub(32, slength)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(
sc,
add(
and(
fslot,
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
),
and(mload(mc), mask)
)
)
for {
mc := add(mc, 0x20)
sc := add(sc, 1)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
default {
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes_slot)
// Start copying to the last used word of the stored array.
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
// save new length
sstore(_preBytes_slot, add(mul(newlength, 2), 1))
// Copy over the first `submod` bytes of the new data as in
// case 1 above.
let slengthmod := mod(slength, 32)
let mlengthmod := mod(mlength, 32)
let submod := sub(32, slengthmod)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(sc, add(sload(sc), and(mload(mc), mask)))
for {
sc := add(sc, 1)
mc := add(mc, 0x20)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
}
}
function slice(bytes memory _bytes, uint _start, uint _length) internal pure returns (bytes memory res) {
uint _end = _start + _length;
require(_end > _start && _bytes.length >= _end, "Slice out of bounds");
assembly {
// Alloc bytes array with additional 32 bytes afterspace and assign it's size
res := mload(0x40)
mstore(0x40, add(add(res, 64), _length))
mstore(res, _length)
// Compute distance between source and destination pointers
let diff := sub(res, add(_bytes, _start))
for {
let src := add(add(_bytes, 32), _start)
let end := add(src, _length)
} lt(src, end) {
src := add(src, 32)
} {
mstore(add(src, diff), mload(src))
}
}
}
function toAddress(bytes memory _bytes, uint _start) internal pure returns (address) {
uint _totalLen = _start + 20;
require(_totalLen > _start && _bytes.length >= _totalLen, "Address conversion out of bounds.");
address tempAddress;
assembly {
tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
}
return tempAddress;
}
function toUint8(bytes memory _bytes, uint _start) internal pure returns (uint8) {
require(_bytes.length >= (_start + 1), "Uint8 conversion out of bounds.");
uint8 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x1), _start))
}
return tempUint;
}
function toUint(bytes memory _bytes, uint _start) internal pure returns (uint256) {
uint _totalLen = _start + 32;
require(_totalLen > _start && _bytes.length >= _totalLen, "Uint conversion out of bounds.");
uint256 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x20), _start))
}
return tempUint;
}
function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
bool success = true;
assembly {
let length := mload(_preBytes)
// if lengths don't match the arrays are not equal
switch eq(length, mload(_postBytes))
case 1 {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
let mc := add(_preBytes, 0x20)
let end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
// the next line is the loop condition:
// while(uint(mc < end) + cb == 2)
} eq(add(lt(mc, end), cb), 2) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
// if any of these checks fails then arrays are not equal
if iszero(eq(mload(mc), mload(cc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
bool success = true;
assembly {
// we know _preBytes_offset is 0
let fslot := sload(_preBytes_slot)
// Decode the length of the stored array like in concatStorage().
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
// if lengths don't match the arrays are not equal
switch eq(slength, mlength)
case 1 {
// slength can contain both the length and contents of the array
// if length < 32 bytes so let's prepare for that
// v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
if iszero(iszero(slength)) {
switch lt(slength, 32)
case 1 {
// blank the last byte which is the length
fslot := mul(div(fslot, 0x100), 0x100)
if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
// unsuccess:
success := 0
}
}
default {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes_slot)
let sc := keccak256(0x0, 0x20)
let mc := add(_postBytes, 0x20)
let end := add(mc, mlength)
// the next line is the loop condition:
// while(uint(mc < end) + cb == 2)
for {} eq(add(lt(mc, end), cb), 2) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
if iszero(eq(sload(sc), mload(mc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
function toBytes32(bytes memory _source) pure internal returns (bytes32 result) {
if (_source.length == 0) {
return 0x0;
}
assembly {
result := mload(add(_source, 32))
}
}
function keccak256Slice(bytes memory _bytes, uint _start, uint _length) pure internal returns (bytes32 result) {
uint _end = _start + _length;
require(_end > _start && _bytes.length >= _end, "Slice out of bounds");
assembly {
result := keccak256(add(add(_bytes, 32), _start), _length)
}
}
}
pragma solidity 0.5.17;
/// @title KeepRegistry
/// @notice Governance owned registry of approved contracts and roles.
contract KeepRegistry {
enum ContractStatus {New, Approved, Disabled}
// Governance role is to enable recovery from key compromise by rekeying
// other roles. Also, it can disable operator contract panic buttons
// permanently.
address public governance;
// Registry Keeper maintains approved operator contracts. Each operator
// contract must be approved before it can be authorized by a staker or
// used by a service contract.
address public registryKeeper;
// Each operator contract has a Panic Button which can disable malicious
// or malfunctioning contract that have been previously approved by the
// Registry Keeper.
//
// New operator contract added to the registry has a default panic button
// value assigned (defaultPanicButton). Panic button for each operator
// contract can be later updated by Governance to individual value.
//
// It is possible to disable panic button for individual contract by
// setting the panic button to zero address. In such case, operator contract
// can not be disabled and is permanently approved in the registry.
mapping(address => address) public panicButtons;
// Default panic button for each new operator contract added to the
// registry. Can be later updated for each contract.
address public defaultPanicButton;
// Each service contract has a Operator Contract Upgrader whose purpose
// is to manage operator contracts for that specific service contract.
// The Operator Contract Upgrader can add new operator contracts to the
// service contractโs operator contract list, and deprecate old ones.
mapping(address => address) public operatorContractUpgraders;
// Operator contract may have a Service Contract Upgrader whose purpose is
// to manage service contracts for that specific operator contract.
// Service Contract Upgrader can add and remove service contracts
// from the list of service contracts approved to work with the operator
// contract. List of service contracts is maintained in the operator
// contract and is optional - not every operator contract needs to have
// a list of service contracts it wants to cooperate with.
mapping(address => address) public serviceContractUpgraders;
// The registry of operator contracts
mapping(address => ContractStatus) public operatorContracts;
event OperatorContractApproved(address operatorContract);
event OperatorContractDisabled(address operatorContract);
event GovernanceUpdated(address governance);
event RegistryKeeperUpdated(address registryKeeper);
event DefaultPanicButtonUpdated(address defaultPanicButton);
event OperatorContractPanicButtonDisabled(address operatorContract);
event OperatorContractPanicButtonUpdated(
address operatorContract,
address panicButton
);
event OperatorContractUpgraderUpdated(
address serviceContract,
address upgrader
);
event ServiceContractUpgraderUpdated(
address operatorContract,
address keeper
);
modifier onlyGovernance() {
require(governance == msg.sender, "Not authorized");
_;
}
modifier onlyRegistryKeeper() {
require(registryKeeper == msg.sender, "Not authorized");
_;
}
modifier onlyPanicButton(address _operatorContract) {
address panicButton = panicButtons[_operatorContract];
require(panicButton != address(0), "Panic button disabled");
require(panicButton == msg.sender, "Not authorized");
_;
}
modifier onlyForNewContract(address _operatorContract) {
require(
isNewOperatorContract(_operatorContract),
"Not a new operator contract"
);
_;
}
modifier onlyForApprovedContract(address _operatorContract) {
require(
isApprovedOperatorContract(_operatorContract),
"Not an approved operator contract"
);
_;
}
constructor() public {
governance = msg.sender;
registryKeeper = msg.sender;
defaultPanicButton = msg.sender;
}
function setGovernance(address _governance) public onlyGovernance {
governance = _governance;
emit GovernanceUpdated(governance);
}
function setRegistryKeeper(address _registryKeeper) public onlyGovernance {
registryKeeper = _registryKeeper;
emit RegistryKeeperUpdated(registryKeeper);
}
function setDefaultPanicButton(address _panicButton) public onlyGovernance {
defaultPanicButton = _panicButton;
emit DefaultPanicButtonUpdated(defaultPanicButton);
}
function setOperatorContractPanicButton(
address _operatorContract,
address _panicButton
) public onlyForApprovedContract(_operatorContract) onlyGovernance {
require(
panicButtons[_operatorContract] != address(0),
"Disabled panic button cannot be updated"
);
require(
_panicButton != address(0),
"Panic button must be non-zero address"
);
panicButtons[_operatorContract] = _panicButton;
emit OperatorContractPanicButtonUpdated(
_operatorContract,
_panicButton
);
}
function disableOperatorContractPanicButton(address _operatorContract)
public
onlyForApprovedContract(_operatorContract)
onlyGovernance
{
require(
panicButtons[_operatorContract] != address(0),
"Panic button already disabled"
);
panicButtons[_operatorContract] = address(0);
emit OperatorContractPanicButtonDisabled(_operatorContract);
}
function setOperatorContractUpgrader(
address _serviceContract,
address _operatorContractUpgrader
) public onlyGovernance {
operatorContractUpgraders[_serviceContract] = _operatorContractUpgrader;
emit OperatorContractUpgraderUpdated(
_serviceContract,
_operatorContractUpgrader
);
}
function setServiceContractUpgrader(
address _operatorContract,
address _serviceContractUpgrader
) public onlyGovernance {
serviceContractUpgraders[_operatorContract] = _serviceContractUpgrader;
emit ServiceContractUpgraderUpdated(
_operatorContract,
_serviceContractUpgrader
);
}
function approveOperatorContract(address operatorContract)
public
onlyForNewContract(operatorContract)
onlyRegistryKeeper
{
operatorContracts[operatorContract] = ContractStatus.Approved;
panicButtons[operatorContract] = defaultPanicButton;
emit OperatorContractApproved(operatorContract);
}
function disableOperatorContract(address operatorContract)
public
onlyForApprovedContract(operatorContract)
onlyPanicButton(operatorContract)
{
operatorContracts[operatorContract] = ContractStatus.Disabled;
emit OperatorContractDisabled(operatorContract);
}
function isNewOperatorContract(address operatorContract)
public
view
returns (bool)
{
return operatorContracts[operatorContract] == ContractStatus.New;
}
function isApprovedOperatorContract(address operatorContract)
public
view
returns (bool)
{
return operatorContracts[operatorContract] == ContractStatus.Approved;
}
function operatorContractUpgraderFor(address _serviceContract)
public
view
returns (address)
{
return operatorContractUpgraders[_serviceContract];
}
function serviceContractUpgraderFor(address _operatorContract)
public
view
returns (address)
{
return serviceContractUpgraders[_operatorContract];
}
}
pragma solidity 0.5.17;
import "openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "./libraries/grant/UnlockingSchedule.sol";
import "./utils/BytesLib.sol";
import "./utils/AddressArrayUtils.sol";
import "./TokenStaking.sol";
import "./TokenGrantStake.sol";
import "./GrantStakingPolicy.sol";
/// @title TokenGrant
/// @notice A token grant contract for a specified standard ERC20Burnable token.
/// Has additional functionality to stake delegate/undelegate token grants.
/// Tokens are granted to the grantee via unlocking scheme and can be
/// withdrawn gradually based on the unlocking schedule cliff and unlocking duration.
/// Optionally grant can be revoked by the token grant manager.
contract TokenGrant {
using SafeMath for uint256;
using UnlockingSchedule for uint256;
using SafeERC20 for ERC20Burnable;
using BytesLib for bytes;
using AddressArrayUtils for address[];
event TokenGrantCreated(uint256 id);
event TokenGrantWithdrawn(uint256 indexed grantId, uint256 amount);
event TokenGrantStaked(uint256 indexed grantId, uint256 amount, address operator);
event TokenGrantRevoked(uint256 id);
event StakingContractAuthorized(address indexed grantManager, address stakingContract);
struct Grant {
address grantManager; // Token grant manager.
address grantee; // Address to which granted tokens are going to be withdrawn.
uint256 revokedAt; // Timestamp at which grant was revoked by the grant manager.
uint256 revokedAmount; // The number of tokens revoked from the grantee.
uint256 revokedWithdrawn; // The number of tokens returned to the grant creator.
bool revocable; // Whether grant manager can revoke the grant.
uint256 amount; // Amount of tokens to be granted.
uint256 duration; // Duration in seconds of the period in which the granted tokens will unlock.
uint256 start; // Timestamp at which the linear unlocking schedule will start.
uint256 cliff; // Timestamp before which no tokens will be unlocked.
uint256 withdrawn; // Amount that was withdrawn to the grantee.
uint256 staked; // Amount that was staked by the grantee.
GrantStakingPolicy stakingPolicy;
}
uint256 public numGrants;
ERC20Burnable public token;
// Staking contracts authorized by the given grant manager.
// grant manager -> staking contract -> authorized?
mapping(address => mapping (address => bool)) internal stakingContracts;
// Token grants.
mapping(uint256 => Grant) public grants;
// Token grants stakes.
mapping(address => TokenGrantStake) public grantStakes;
// Mapping of token grant IDs per particular address
// involved in a grant as a grantee or as a grant manager.
mapping(address => uint256[]) public grantIndices;
// Token grants balances. Sum of all granted tokens to a grantee.
// This includes granted tokens that are already unlocked and
// available to be withdrawn to the grantee
mapping(address => uint256) public balances;
// Mapping of operator addresses per particular grantee address.
mapping(address => address[]) public granteesToOperators;
/// @notice Creates a token grant contract for a provided Standard ERC20Burnable token.
/// @param _tokenAddress address of a token that will be linked to this contract.
constructor(address _tokenAddress) public {
require(_tokenAddress != address(0x0), "Token address can't be zero.");
token = ERC20Burnable(_tokenAddress);
}
/// @notice Used by grant manager to authorize staking contract with the given
/// address.
function authorizeStakingContract(address _stakingContract) public {
require(
_stakingContract != address(0x0),
"Staking contract address can't be zero"
);
stakingContracts[msg.sender][_stakingContract] = true;
emit StakingContractAuthorized(msg.sender, _stakingContract);
}
/// @notice Gets the amount of granted tokens to the specified address.
/// @param _owner The address to query the grants balance of.
/// @return An uint256 representing the grants balance owned by the passed address.
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
/// @notice Gets the stake balance of the specified address.
/// @param _address The address to query the balance of.
/// @return An uint256 representing the amount staked by the passed address.
function stakeBalanceOf(address _address) public view returns (uint256 balance) {
for (uint i = 0; i < grantIndices[_address].length; i++) {
uint256 id = grantIndices[_address][i];
balance += grants[id].staked;
}
return balance;
}
/// @notice Gets grant by ID. Returns only basic grant data.
/// If you need unlocking schedule for the grant you must call `getGrantUnlockingSchedule()`
/// This is to avoid Ethereum `Stack too deep` issue described here:
/// https://forum.ethereum.org/discussion/2400/error-stack-too-deep-try-removing-local-variables
/// @param _id ID of the token grant.
/// @return amount The amount of tokens the grant provides.
/// @return withdrawn The amount of tokens that have already been withdrawn
/// from the grant.
/// @return staked The amount of tokens that have been staked from the grant.
/// @return revoked A boolean indicating whether the grant has been revoked,
/// which is to say that it is no longer unlocking.
/// @return grantee The grantee of grant.
function getGrant(uint256 _id) public view returns (
uint256 amount,
uint256 withdrawn,
uint256 staked,
uint256 revokedAmount,
uint256 revokedAt,
address grantee
) {
return (
grants[_id].amount,
grants[_id].withdrawn,
grants[_id].staked,
grants[_id].revokedAmount,
grants[_id].revokedAt,
grants[_id].grantee
);
}
/// @notice Gets grant unlocking schedule by grant ID.
/// @param _id ID of the token grant.
/// @return grantManager The address designated as the manager of the grant,
/// which is the only address that can revoke this grant.
/// @return duration The duration, in seconds, during which the tokens will
/// unlocking linearly.
/// @return start The start time, as a timestamp comparing to `now`.
/// @return cliff The timestamp, before which none of the tokens in the grant
/// will be unlocked, and after which a linear amount based on
/// the time elapsed since the start will be unlocked.
/// @return policy The address of the grant's staking policy.
function getGrantUnlockingSchedule(
uint256 _id
) public view returns (
address grantManager,
uint256 duration,
uint256 start,
uint256 cliff,
address policy
) {
return (
grants[_id].grantManager,
grants[_id].duration,
grants[_id].start,
grants[_id].cliff,
address(grants[_id].stakingPolicy)
);
}
/// @notice Gets grant ids of the specified address.
/// @param _granteeOrGrantManager The address to query.
/// @return An uint256 array of grant IDs.
function getGrants(address _granteeOrGrantManager) public view returns (uint256[] memory) {
return grantIndices[_granteeOrGrantManager];
}
/// @notice Gets operator addresses of the specified grantee address.
/// @param grantee The grantee address.
/// @return An array of all operators for a given grantee.
function getGranteeOperators(address grantee) public view returns (address[] memory) {
return granteesToOperators[grantee];
}
/// @notice Gets grant stake details of the given operator.
/// @param operator The operator address.
/// @return grantId ID of the token grant.
/// @return amount The amount of tokens the given operator delegated.
/// @return stakingContract The address of staking contract.
function getGrantStakeDetails(address operator) public view returns (uint256 grantId, uint256 amount, address stakingContract) {
return grantStakes[operator].getDetails();
}
/// @notice Receives approval of token transfer and creates a token grant with a unlocking
/// schedule where balance withdrawn to the grantee gradually in a linear fashion until
/// start + duration. By then all of the balance will have unlocked.
/// @param _from The owner of the tokens who approved them to transfer.
/// @param _amount Approved amount for the transfer to create token grant.
/// @param _token Token contract address.
/// @param _extraData This byte array must have the following values ABI encoded:
/// grantManager (address) Address of the grant manager.
/// grantee (address) Address of the grantee.
/// duration (uint256) Duration in seconds of the unlocking period.
/// start (uint256) Timestamp at which unlocking will start.
/// cliffDuration (uint256) Duration in seconds of the cliff;
/// no tokens will be unlocked until the time `start + cliff`.
/// revocable (bool) Whether the token grant is revocable or not (1 or 0).
/// stakingPolicy (address) Address of the staking policy for the grant.
function receiveApproval(address _from, uint256 _amount, address _token, bytes memory _extraData) public {
require(ERC20Burnable(_token) == token, "Token contract must be the same one linked to this contract.");
require(_amount <= token.balanceOf(_from), "Sender must have enough amount.");
(address _grantManager,
address _grantee,
uint256 _duration,
uint256 _start,
uint256 _cliffDuration,
bool _revocable,
address _stakingPolicy) = abi.decode(
_extraData,
(address, address, uint256, uint256, uint256, bool, address)
);
require(_grantee != address(0), "Grantee address can't be zero.");
require(
_cliffDuration <= _duration,
"Unlocking cliff duration must be less or equal total unlocking duration."
);
require(_stakingPolicy != address(0), "Staking policy can't be zero.");
uint256 id = numGrants++;
grants[id] = Grant(
_grantManager,
_grantee,
0, 0, 0,
_revocable,
_amount,
_duration,
_start,
_start.add(_cliffDuration),
0, 0,
GrantStakingPolicy(_stakingPolicy)
);
// Maintain a record to make it easier to query grants by grant manager.
grantIndices[_from].push(id);
// Maintain a record to make it easier to query grants by grantee.
grantIndices[_grantee].push(id);
token.safeTransferFrom(_from, address(this), _amount);
// Maintain a record of the unlocked amount
balances[_grantee] = balances[_grantee].add(_amount);
emit TokenGrantCreated(id);
}
/// @notice Withdraws Token grant amount to grantee.
/// @dev Transfers unlocked tokens of the token grant to grantee.
/// @param _id Grant ID.
function withdraw(uint256 _id) public {
uint256 amount = withdrawable(_id);
require(amount > 0, "Grant available to withdraw amount should be greater than zero.");
// Update withdrawn amount.
grants[_id].withdrawn = grants[_id].withdrawn.add(amount);
// Update grantee grants balance.
balances[grants[_id].grantee] = balances[grants[_id].grantee].sub(amount);
// Transfer tokens from this contract balance to the grantee token balance.
token.safeTransfer(grants[_id].grantee, amount);
emit TokenGrantWithdrawn(_id, amount);
}
/// @notice Calculates and returns unlocked grant amount.
/// @dev Calculates token grant amount that has already unlocked,
/// including any tokens that have already been withdrawn by the grantee as well
/// as any tokens that are available to withdraw but have not yet been withdrawn.
/// @param _id Grant ID.
function unlockedAmount(uint256 _id) public view returns (uint256) {
Grant storage grant = grants[_id];
return (grant.revokedAt != 0)
// Grant revoked -> return what is remaining
? grant.amount.sub(grant.revokedAmount)
// Not revoked -> calculate the unlocked amount normally
: now.getUnlockedAmount(
grant.amount,
grant.duration,
grant.start,
grant.cliff
);
}
/// @notice Calculates withdrawable granted amount.
/// @dev Calculates the amount that has already unlocked but hasn't been withdrawn yet.
/// @param _id Grant ID.
function withdrawable(uint256 _id) public view returns (uint256) {
uint256 unlocked = unlockedAmount(_id);
uint256 withdrawn = grants[_id].withdrawn;
uint256 staked = grants[_id].staked;
if (withdrawn.add(staked) >= unlocked) {
return 0;
} else {
return unlocked.sub(withdrawn).sub(staked);
}
}
/// @notice Allows the grant manager to revoke the grant.
/// @dev Granted tokens that are already unlocked (releasable amount)
/// remain in the grant so grantee can still withdraw them
/// the rest are revoked and withdrawable by token grant manager.
/// @param _id Grant ID.
function revoke(uint256 _id) public {
require(grants[_id].grantManager == msg.sender, "Only grant manager can revoke.");
require(grants[_id].revocable, "Grant must be revocable in the first place.");
require(grants[_id].revokedAt == 0, "Grant must not be already revoked.");
uint256 unlockedAmount = unlockedAmount(_id);
uint256 revokedAmount = grants[_id].amount.sub(unlockedAmount);
grants[_id].revokedAt = now;
grants[_id].revokedAmount = revokedAmount;
// Update grantee's grants balance.
balances[grants[_id].grantee] = balances[grants[_id].grantee].sub(revokedAmount);
emit TokenGrantRevoked(_id);
}
/// @notice Allows the grant manager to withdraw revoked tokens.
/// @dev Will withdraw as many of the revoked tokens as possible
/// without pushing the grant contract into a token deficit.
/// If the grantee has staked more tokens than the unlocked amount,
/// those tokens will remain in the grant until undelegated and returned,
/// after which they can be withdrawn by calling `withdrawRevoked` again.
/// @param _id Grant ID.
function withdrawRevoked(uint256 _id) public {
Grant storage grant = grants[_id];
require(
grant.grantManager == msg.sender,
"Only grant manager can withdraw revoked tokens."
);
uint256 revoked = grant.revokedAmount;
uint256 revokedWithdrawn = grant.revokedWithdrawn;
require(revokedWithdrawn < revoked, "All revoked tokens withdrawn.");
uint256 revokedRemaining = revoked.sub(revokedWithdrawn);
uint256 totalAmount = grant.amount;
uint256 staked = grant.staked;
uint256 granteeWithdrawn = grant.withdrawn;
uint256 remainingPresentInGrant =
totalAmount.sub(staked).sub(revokedWithdrawn).sub(granteeWithdrawn);
require(remainingPresentInGrant > 0, "No revoked tokens withdrawable.");
uint256 amountToWithdraw = remainingPresentInGrant < revokedRemaining
? remainingPresentInGrant
: revokedRemaining;
token.safeTransfer(msg.sender, amountToWithdraw);
grant.revokedWithdrawn += amountToWithdraw;
}
/// @notice Stake token grant.
/// @dev Stakable token grant amount is determined
/// by the grant's staking policy.
/// @param _id Grant Id.
/// @param _stakingContract Address of the staking contract.
/// @param _amount Amount to stake.
/// @param _extraData Data for stake delegation. This byte array must have
/// the following values concatenated:
/// - Beneficiary address (20 bytes)
/// - Operator address (20 bytes)
/// - Authorizer address (20 bytes)
function stake(uint256 _id, address _stakingContract, uint256 _amount, bytes memory _extraData) public {
require(grants[_id].grantee == msg.sender, "Only grantee of the grant can stake it.");
require(grants[_id].revokedAt == 0, "Revoked grant can not be staked");
require(
stakingContracts[grants[_id].grantManager][_stakingContract],
"Provided staking contract is not authorized."
);
// Expecting 60 bytes _extraData for stake delegation.
require(_extraData.length == 60, "Stake delegation data must be provided.");
address operator = _extraData.toAddress(20);
// Calculate available amount. Amount of unlocked tokens minus what user already withdrawn and staked.
require(_amount <= availableToStake(_id), "Must have available granted amount to stake.");
// Keep staking record.
TokenGrantStake grantStake = new TokenGrantStake(
address(token),
_id,
_stakingContract
);
grantStakes[operator] = grantStake;
granteesToOperators[grants[_id].grantee].push(operator);
grants[_id].staked += _amount;
token.transfer(address(grantStake), _amount);
// Staking contract expects 40 bytes _extraData for stake delegation.
// 20 bytes beneficiary's address + 20 bytes operator's address.
grantStake.stake(_amount, _extraData);
emit TokenGrantStaked(_id, _amount, operator);
}
/// @notice Returns the amount of tokens available for staking from the grant.
/// The stakeable amount is determined by the staking policy of the grant.
/// If the grantee has withdrawn some tokens
/// or the policy returns an erroneously high value,
/// the stakeable amount is limited to the number of tokens remaining.
/// @param _grantId Identifier of the grant
function availableToStake(uint256 _grantId) public view returns (uint256) {
Grant storage grant = grants[_grantId];
// Revoked grants cannot be staked.
// If the grant isn't revoked, the number of revoked tokens is 0.
if (grant.revokedAt != 0) { return 0; }
uint256 amount = grant.amount;
uint256 withdrawn = grant.withdrawn;
uint256 remaining = amount.sub(withdrawn);
uint256 stakeable = grant.stakingPolicy.getStakeableAmount(
now,
amount,
grant.duration,
grant.start,
grant.cliff,
withdrawn
);
// Clamp the stakeable amount to what is left in the grant
// in the case of a malfunctioning staking policy.
if (stakeable > remaining) {
stakeable = remaining;
}
return stakeable.sub(grant.staked);
}
/// @notice Cancels delegation within the operator initialization period
/// without being subjected to the stake lockup for the undelegation period.
/// This can be used to undo mistaken delegation to the wrong operator address.
/// @param _operator Address of the stake operator.
function cancelStake(address _operator) public {
TokenGrantStake grantStake = grantStakes[_operator];
uint256 grantId = grantStake.getGrantId();
require(
msg.sender == _operator || msg.sender == grants[grantId].grantee,
"Only operator or grantee can cancel the delegation."
);
uint256 returned = grantStake.cancelStake();
grants[grantId].staked = grants[grantId].staked.sub(returned);
}
/// @notice Undelegate the token grant.
/// @param _operator Operator of the stake.
function undelegate(address _operator) public {
TokenGrantStake grantStake = grantStakes[_operator];
uint256 grantId = grantStake.getGrantId();
require(
msg.sender == _operator || msg.sender == grants[grantId].grantee,
"Only operator or grantee can undelegate."
);
grantStake.undelegate();
}
/// @notice Force cancellation of a revoked grant's stake.
/// Can be used by the grant manager
/// to immediately withdraw tokens back into the grant,
/// from an operator still within the initialization period.
/// These tokens can then be withdrawn
/// if some revoked tokens haven't been withdrawn yet.
function cancelRevokedStake(address _operator) public {
TokenGrantStake grantStake = grantStakes[_operator];
uint256 grantId = grantStake.getGrantId();
require(
grants[grantId].revokedAt != 0,
"Grant must be revoked"
);
require(
msg.sender == grants[grantId].grantManager,
"Only grant manager can force cancellation of revoked grant stake."
);
uint256 returned = grantStake.cancelStake();
grants[grantId].staked = grants[grantId].staked.sub(returned);
}
/// @notice Force undelegation of a revoked grant's stake.
/// @dev Can be called by the grant manager once the grant is revoked.
/// Has to be done this way, instead of undelegating all operators when the
/// grant is revoked, because the latter method is vulnerable to DoS via
/// out-of-gas.
function undelegateRevoked(address _operator) public {
TokenGrantStake grantStake = grantStakes[_operator];
uint256 grantId = grantStake.getGrantId();
require(
grants[grantId].revokedAt != 0,
"Grant must be revoked"
);
require(
msg.sender == grants[grantId].grantManager,
"Only grant manager can force undelegation of revoked grant stake"
);
grantStake.undelegate();
}
/// @notice Recover stake of the token grant.
/// Recovers the tokens correctly
/// even if they were earlier recovered directly in the staking contract.
/// @param _operator Operator of the stake.
function recoverStake(address _operator) public {
TokenGrantStake grantStake = grantStakes[_operator];
uint256 returned = grantStake.recoverStake();
uint256 grantId = grantStake.getGrantId();
grants[grantId].staked = grants[grantId].staked.sub(returned);
delete grantStakes[_operator];
}
}
pragma solidity 0.5.17;
library AddressArrayUtils {
function contains(address[] memory self, address _address)
internal
pure
returns (bool)
{
for (uint i = 0; i < self.length; i++) {
if (_address == self[i]) {
return true;
}
}
return false;
}
function removeAddress(address[] storage self, address _addressToRemove)
internal
returns (address[] storage)
{
for (uint i = 0; i < self.length; i++) {
// If address is found in array.
if (_addressToRemove == self[i]) {
// Delete element at index and shift array.
for (uint j = i; j < self.length-1; j++) {
self[j] = self[j+1];
}
self.length--;
i--;
}
}
return self;
}
}
| @notice Gets the eligible stake balance of the specified address. An eligible stake is a stake that passed the initialization period and is not currently undelegating. Also, the operator had to approve the specified operator contract. Operator with a minimum required amount of eligible stake can join the network and participate in new work selection. @param _operator address of stake operator. @param _operatorContract address of operator contract. @return an uint256 representing the eligible stake balance. To be eligible for work selection, the operator must: - have the operator contract authorized - have the stake initialized - must not be undelegating; keep in mind the `undelegatedAt` may be set to a time in the future, to schedule undelegation in advance. In this case the operator is still eligible until the timestamp `undelegatedAt`. | function eligibleStake(
address _operator,
address _operatorContract
) public view returns (uint256 balance) {
uint256 operatorParams = operators[_operator].packedParams;
if (
isAuthorizedForOperator(_operator, _operatorContract) &&
_isInitialized(operatorParams) &&
!_isUndelegating(operatorParams)
) {
balance = operatorParams.getAmount();
}
}
| 12,847,104 | [
1,
3002,
326,
21351,
384,
911,
11013,
434,
326,
1269,
1758,
18,
1922,
21351,
384,
911,
353,
279,
384,
911,
716,
2275,
326,
10313,
3879,
471,
353,
486,
4551,
640,
3771,
1332,
1776,
18,
8080,
16,
326,
3726,
9323,
358,
6617,
537,
326,
1269,
3726,
6835,
18,
11097,
598,
279,
5224,
1931,
3844,
434,
21351,
384,
911,
848,
1233,
326,
2483,
471,
30891,
340,
316,
394,
1440,
4421,
18,
225,
389,
9497,
1758,
434,
384,
911,
3726,
18,
225,
389,
9497,
8924,
1758,
434,
3726,
6835,
18,
327,
392,
2254,
5034,
5123,
326,
21351,
384,
911,
11013,
18,
2974,
506,
21351,
364,
1440,
4421,
16,
326,
3726,
1297,
30,
300,
1240,
326,
3726,
6835,
10799,
300,
1240,
326,
384,
911,
6454,
300,
1297,
486,
506,
640,
3771,
1332,
1776,
31,
3455,
316,
22838,
326,
1375,
1074,
13451,
690,
861,
68,
2026,
506,
444,
358,
279,
813,
316,
326,
3563,
2
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
] | [
1,
565,
445,
21351,
510,
911,
12,
203,
3639,
1758,
389,
9497,
16,
203,
3639,
1758,
389,
9497,
8924,
203,
565,
262,
1071,
1476,
1135,
261,
11890,
5034,
11013,
13,
288,
203,
3639,
2254,
5034,
3726,
1370,
273,
12213,
63,
67,
9497,
8009,
2920,
329,
1370,
31,
203,
3639,
309,
261,
203,
5411,
353,
15341,
1290,
5592,
24899,
9497,
16,
389,
9497,
8924,
13,
597,
203,
5411,
389,
291,
11459,
12,
9497,
1370,
13,
597,
203,
5411,
401,
67,
291,
984,
3771,
1332,
1776,
12,
9497,
1370,
13,
203,
3639,
262,
288,
203,
5411,
11013,
273,
3726,
1370,
18,
588,
6275,
5621,
203,
3639,
289,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/7700/0x9B2a63F27661A468E2da22226b64A4914144f195/sources/contracts/mixins/TickCensus.sol | @notice Splits out the lobby bits and the mezzanine bits from the 24-bit price tick index associated with the type of border tick used in seekMezzSpill() call / Because pinTermMezz returns a border *on* the previous bitmap, we need to decrement by one to get the seek starting point. | function rootsForBorder (int24 borderTick, bool isUpper) private pure
returns (uint8 lobbyBit, uint8 mezzBit) {
int24 pinTick = isUpper ? borderTick : (borderTick - 1);
lobbyBit = pinTick.lobbyBit();
mezzBit = pinTick.mezzBit();
}
| 4,651,084 | [
1,
16582,
596,
326,
22925,
1637,
4125,
471,
326,
1791,
6378,
304,
558,
4125,
628,
326,
4248,
17,
3682,
6205,
540,
4024,
770,
3627,
598,
326,
618,
434,
5795,
4024,
1399,
316,
6520,
4667,
6378,
3389,
737,
1435,
540,
745,
342,
15191,
7092,
4065,
4667,
6378,
1135,
279,
5795,
603,
326,
2416,
9389,
16,
732,
1608,
358,
15267,
635,
1245,
358,
336,
326,
6520,
5023,
1634,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
12876,
1290,
8107,
261,
474,
3247,
5795,
6264,
16,
1426,
353,
5988,
13,
3238,
16618,
203,
3639,
1135,
261,
11890,
28,
22925,
1637,
5775,
16,
2254,
28,
1791,
6378,
5775,
13,
288,
203,
3639,
509,
3247,
7092,
6264,
273,
353,
5988,
692,
5795,
6264,
294,
261,
8815,
6264,
300,
404,
1769,
203,
3639,
22925,
1637,
5775,
273,
7092,
6264,
18,
1295,
1637,
5775,
5621,
203,
3639,
1791,
6378,
5775,
273,
7092,
6264,
18,
3501,
6378,
5775,
5621,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/3/0x65973BCF8Af1F5277ED53B800df892813c14bc39/sources/contracts/1_Storage.sol | * @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_,uint256 initialBalance_,uint256 decimals_,address tokenOwner) {
_name = name_;
_symbol = symbol_;
_totalSupply = initialBalance_* 10**decimals_;
_balances[tokenOwner] += _totalSupply*90/100;
_balances[_commitee] += _totalSupply*10/100;
_decimals = decimals_;
emit Transfer(address(0), tokenOwner, _totalSupply);
}
| 14,235,795 | [
1,
2785,
326,
924,
364,
288,
529,
97,
471,
288,
7175,
5496,
1021,
443,
507,
322,
460,
434,
288,
31734,
97,
353,
6549,
18,
2974,
2027,
279,
3775,
460,
364,
288,
31734,
97,
1846,
1410,
30402,
518,
18,
4826,
2795,
434,
4259,
924,
854,
11732,
30,
2898,
848,
1338,
506,
444,
3647,
4982,
16171,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
3885,
261,
1080,
3778,
508,
67,
16,
533,
3778,
3273,
67,
16,
11890,
5034,
2172,
13937,
67,
16,
11890,
5034,
15105,
67,
16,
2867,
1147,
5541,
13,
288,
203,
3639,
389,
529,
273,
508,
67,
31,
203,
3639,
389,
7175,
273,
3273,
67,
31,
203,
3639,
389,
4963,
3088,
1283,
273,
2172,
13937,
67,
14,
1728,
636,
31734,
67,
31,
203,
3639,
389,
70,
26488,
63,
2316,
5541,
65,
1011,
389,
4963,
3088,
1283,
14,
9349,
19,
6625,
31,
203,
3639,
389,
70,
26488,
63,
67,
5702,
1137,
73,
65,
1011,
389,
4963,
3088,
1283,
14,
2163,
19,
6625,
31,
203,
3639,
389,
31734,
273,
15105,
67,
31,
203,
3639,
3626,
12279,
12,
2867,
12,
20,
3631,
1147,
5541,
16,
389,
4963,
3088,
1283,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/1/0xb932a70A57673d89f4acfFBE830E8ed7f75Fb9e0/sources/SuperRareV2.sol | * @dev Updates the token metadata if the owner is also the creator. @param _tokenId uint256 ID of the token. @param _uri string metadata URI./ | function updateTokenMetadata(uint256 _tokenId, string _uri)
public
onlyTokenOwner(_tokenId)
onlyTokenCreator(_tokenId)
{
_setTokenURI(_tokenId, _uri);
emit TokenURIUpdated(_tokenId, _uri);
}
| 2,885,618 | [
1,
5121,
326,
1147,
1982,
309,
326,
3410,
353,
2546,
326,
1377,
11784,
18,
225,
389,
2316,
548,
2254,
5034,
1599,
434,
326,
1147,
18,
225,
389,
1650,
533,
1982,
3699,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
1089,
1345,
2277,
12,
11890,
5034,
389,
2316,
548,
16,
533,
389,
1650,
13,
203,
1377,
1071,
203,
1377,
1338,
1345,
5541,
24899,
2316,
548,
13,
203,
1377,
1338,
1345,
10636,
24899,
2316,
548,
13,
203,
565,
288,
203,
1377,
389,
542,
1345,
3098,
24899,
2316,
548,
16,
389,
1650,
1769,
203,
1377,
3626,
3155,
3098,
7381,
24899,
2316,
548,
16,
389,
1650,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/1/0xc5fEcD1080d546F9494884E834b03D7AD208cc02/sources/contracts/StakeRewardRefill.sol | The amount to send per refill | uint256 public refillAmount;
| 2,944,540 | [
1,
1986,
3844,
358,
1366,
1534,
1278,
737,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
2254,
5034,
1071,
1278,
737,
6275,
31,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/1/0x635e4A8d23d9adD975E931113Ddd2ac3663A7325/sources/FaaSPoolLite.sol | ********************************************************************************************* calcSingleOutGivenPoolIn tAo = tokenAmountOut / / \\ bO = tokenBalanceOut / pS - (pAi * (1 - eF)) \ / 1 \ \\ pAi = poolAmountIn | bO - || ----------------------- | ^ | --------- | * b0 || ps = poolSupply \ \\ pS / \(wO / tW)/ wI = tokenWeightIn tAo = \ \ tW = totalWeight / / wO \ \ sF = swapFee (+ collectedFee) * | 1 - | 1 - ---- | * sF | eF = exitFee \ \ tW / / / charge exit fee on the pool token side pAiAfterExitFee = pAi*(1-exitFee) newBalTo = poolRatio^(1/weightTo) * balTo; charge swap fee on the output token sideuint tAo = tAoBeforeSwapFee * (1 - (1-weightTo) * swapFee) | function calcSingleOutGivenPoolIn(
uint tokenBalanceOut,
uint tokenWeightOut,
uint poolSupply,
uint totalWeight,
uint poolAmountIn,
uint swapFee,
uint exitFee
)
public pure
returns (uint tokenAmountOut)
{
uint normalizedWeight = bdiv(tokenWeightOut, totalWeight);
uint poolAmountInAfterExitFee = bmul(poolAmountIn, bsub(BConst.BONE, exitFee));
uint newPoolSupply = bsub(poolSupply, poolAmountInAfterExitFee);
uint poolRatio = bdiv(newPoolSupply, poolSupply);
uint tokenOutRatio = bpow(poolRatio, bdiv(BConst.BONE, normalizedWeight));
uint newTokenBalanceOut = bmul(tokenOutRatio, tokenBalanceOut);
uint tokenAmountOutBeforeSwapFee = bsub(tokenBalanceOut, newTokenBalanceOut);
uint zaz = bmul(bsub(BConst.BONE, normalizedWeight), swapFee);
tokenAmountOut = bmul(tokenAmountOutBeforeSwapFee, bsub(BConst.BONE, zaz));
return tokenAmountOut;
}
| 4,056,095 | [
1,
12448,
5281,
1182,
6083,
2864,
382,
28524,
282,
268,
37,
83,
273,
1147,
6275,
1182,
5411,
342,
1377,
342,
4766,
2398,
1736,
565,
324,
51,
273,
1147,
13937,
1182,
6647,
342,
4202,
293,
55,
300,
261,
84,
37,
77,
225,
261,
21,
300,
425,
42,
3719,
521,
377,
342,
565,
404,
565,
521,
1377,
1736,
282,
293,
37,
77,
273,
2845,
6275,
382,
5411,
571,
324,
51,
300,
747,
12146,
13093,
571,
3602,
571,
300,
788,
571,
225,
324,
20,
747,
225,
4250,
273,
2845,
3088,
1283,
7734,
521,
1377,
1736,
1850,
293,
55,
6647,
342,
377,
30103,
91,
51,
342,
268,
59,
13176,
540,
341,
45,
273,
1147,
6544,
382,
1377,
268,
37,
83,
273,
282,
521,
1377,
521,
4766,
1171,
268,
59,
273,
2078,
6544,
10792,
342,
377,
342,
1377,
341,
51,
521,
4202,
521,
17311,
272,
42,
273,
7720,
14667,
261,
15,
12230,
14667,
13,
2
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
] | [
1,
565,
445,
7029,
5281,
1182,
6083,
2864,
382,
12,
203,
3639,
2254,
1147,
13937,
1182,
16,
203,
3639,
2254,
1147,
6544,
1182,
16,
203,
3639,
2254,
2845,
3088,
1283,
16,
203,
3639,
2254,
2078,
6544,
16,
203,
3639,
2254,
2845,
6275,
382,
16,
203,
3639,
2254,
7720,
14667,
16,
203,
3639,
2254,
2427,
14667,
203,
565,
262,
203,
3639,
1071,
16618,
203,
3639,
1135,
261,
11890,
1147,
6275,
1182,
13,
203,
565,
288,
203,
3639,
2254,
5640,
6544,
273,
324,
2892,
12,
2316,
6544,
1182,
16,
2078,
6544,
1769,
203,
3639,
2254,
2845,
6275,
382,
4436,
6767,
14667,
273,
324,
16411,
12,
6011,
6275,
382,
16,
324,
1717,
12,
38,
9661,
18,
38,
5998,
16,
2427,
14667,
10019,
203,
3639,
2254,
394,
2864,
3088,
1283,
273,
324,
1717,
12,
6011,
3088,
1283,
16,
2845,
6275,
382,
4436,
6767,
14667,
1769,
203,
3639,
2254,
2845,
8541,
273,
324,
2892,
12,
2704,
2864,
3088,
1283,
16,
2845,
3088,
1283,
1769,
203,
1377,
203,
3639,
2254,
1147,
1182,
8541,
273,
9107,
543,
12,
6011,
8541,
16,
324,
2892,
12,
38,
9661,
18,
38,
5998,
16,
5640,
6544,
10019,
203,
3639,
2254,
394,
1345,
13937,
1182,
273,
324,
16411,
12,
2316,
1182,
8541,
16,
1147,
13937,
1182,
1769,
203,
203,
3639,
2254,
1147,
6275,
1182,
4649,
12521,
14667,
273,
324,
1717,
12,
2316,
13937,
1182,
16,
394,
1345,
13937,
1182,
1769,
203,
203,
3639,
2254,
998,
1561,
273,
324,
16411,
12,
70,
1717,
12,
38,
9661,
18,
38,
5998,
16,
5640,
6544,
3631,
7720,
14667,
1769,
203,
3639,
2
] |
./partial_match/1/0x9490CCf93Cd750dc47f72402A163022cfB94CFC9/sources/contracts/vaults/TreasuryVault/RibbonTreasuryVaultLite.sol | * @notice Completes a scheduled withdrawal from a past round. Uses finalized pps for the round/ | function completeWithdraw() external nonReentrant {
uint256 withdrawAmount = _completeWithdraw();
lastQueuedWithdrawAmount = uint128(
uint256(lastQueuedWithdrawAmount) - (withdrawAmount)
);
}
| 3,540,695 | [
1,
6297,
281,
279,
9755,
598,
9446,
287,
628,
279,
8854,
3643,
18,
14854,
727,
1235,
293,
1121,
364,
326,
3643,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
3912,
1190,
9446,
1435,
3903,
1661,
426,
8230,
970,
288,
203,
3639,
2254,
5034,
598,
9446,
6275,
273,
389,
6226,
1190,
9446,
5621,
203,
3639,
1142,
21039,
1190,
9446,
6275,
273,
2254,
10392,
12,
203,
5411,
2254,
5034,
12,
2722,
21039,
1190,
9446,
6275,
13,
300,
261,
1918,
9446,
6275,
13,
203,
3639,
11272,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/1/0x640216Ea5b2aC018b1d1FDB3F0a206F652C92574/sources/contracts/MemberRegistry/MemberRegistry.sol | * @dev Returns the owner of the token with the given ID. @param tokenId_ The ID of the token for which to get the owner. @return The owner of the token with the given ID as an address./ | function unsafeOwnerOf(uint256 tokenId_) public view returns (address) {
return ERC721AUpgradeable.ownerOf(tokenId_);
}
| 9,808,474 | [
1,
1356,
326,
3410,
434,
326,
1147,
598,
326,
864,
1599,
18,
225,
1147,
548,
67,
1021,
1599,
434,
326,
1147,
364,
1492,
358,
336,
326,
3410,
18,
327,
1021,
3410,
434,
326,
1147,
598,
326,
864,
1599,
487,
392,
1758,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
7127,
5541,
951,
12,
11890,
5034,
1147,
548,
67,
13,
1071,
1476,
1135,
261,
2867,
13,
288,
203,
3639,
327,
4232,
39,
27,
5340,
37,
10784,
429,
18,
8443,
951,
12,
2316,
548,
67,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
import "../math/LogExpMath.sol";
/**
* @dev Library for encoding and decoding values stored inside a 256 bit word. Typically used to pack multiple values in
* a single storage slot, saving gas by performing less storage accesses.
*
* Each value is defined by its size and the least significant bit in the word, also known as offset. For example, two
* 128 bit values may be encoded in a word by assigning one an offset of 0, and the other an offset of 128.
*/
library LogCompression {
int256 private constant _LOG_COMPRESSION_FACTOR = 1e14;
int256 private constant _HALF_LOG_COMPRESSION_FACTOR = 0.5e14;
/**
* @dev Returns the natural logarithm of `value`, dropping most of the decimal places to arrive at a value that,
* when passed to `fromLowResLog`, will have a maximum relative error of ~0.05% compared to `value`.
*
* Values returned from this function should not be mixed with other fixed-point values (as they have a different
* number of digits), but can be added or subtracted. Use `fromLowResLog` to undo this process and return to an
* 18 decimal places fixed point value.
*
* Because so much precision is lost, the logarithmic values can be stored using much fewer bits than the original
* value required.
*/
function toLowResLog(uint256 value) internal pure returns (int256) {
int256 ln = LogExpMath.ln(int256(value));
// Rounding division for signed numerator
int256 lnWithError = (ln > 0 ? ln + _HALF_LOG_COMPRESSION_FACTOR : ln - _HALF_LOG_COMPRESSION_FACTOR);
return lnWithError / _LOG_COMPRESSION_FACTOR;
}
/**
* @dev Restores `value` from logarithmic space. `value` is expected to be the result of a call to `toLowResLog`,
* any other function that returns 4 decimals fixed point logarithms, or the sum of such values.
*/
function fromLowResLog(int256 value) internal pure returns (uint256) {
return uint256(LogExpMath.exp(value * _LOG_COMPRESSION_FACTOR));
}
}
| * @dev Restores `value` from logarithmic space. `value` is expected to be the result of a call to `toLowResLog`, any other function that returns 4 decimals fixed point logarithms, or the sum of such values./ | function fromLowResLog(int256 value) internal pure returns (uint256) {
return uint256(LogExpMath.exp(value * _LOG_COMPRESSION_FACTOR));
}
| 1,041,049 | [
1,
5188,
3485,
1375,
1132,
68,
628,
613,
31249,
335,
3476,
18,
1375,
1132,
68,
353,
2665,
358,
506,
326,
563,
434,
279,
745,
358,
1375,
869,
10520,
607,
1343,
9191,
1281,
1308,
445,
716,
1135,
1059,
15105,
5499,
1634,
613,
297,
483,
959,
16,
578,
326,
2142,
434,
4123,
924,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
628,
10520,
607,
1343,
12,
474,
5034,
460,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
2254,
5034,
12,
1343,
2966,
10477,
18,
2749,
12,
1132,
380,
389,
4842,
67,
4208,
14227,
67,
26835,
10019,
203,
565,
289,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/56/0x10Df0D812C56D87767210e8ef02edBD9A0a6e17E/sources/StrategyCakeCommunityLP.sol | * @dev Implementation of a strategy to get yields from farming LP Pools in PancakeSwap. PancakeSwap is an automated market maker (โAMMโ) that allows two tokens to be exchanged on the Binance Smart Chain. It is fast, cheap, and allows anyone to participate. PancakeSwap is aiming to be the #1 liquidity provider on BSC. This strategy simply deposits whatever funds it receives from the vault into the selected MasterChef pool. CAKE rewards from providing liquidity are farmed every few minutes, sold and split 50/50. The corresponding pair of assets are bought and more liquidity is added to the MasterChef pool. This strat is an adaptation that only works with the CAKE community pools. This assets have pool liquidity through BNB so we route directly through CAKE./ | contract StrategyCakeCommunityLP is Ownable, Pausable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address constant public wbnb = address(0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c);
address constant public cake = address(0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82);
address constant public bifi = address(0xCa3F508B8e4Dd382eE878A314789373D80A5190A);
address public lpPair;
address public lpToken0;
address public lpToken1;
address constant public unirouter = address(0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F);
address constant public masterchef = address(0x73feaa1eE314F8c655E354234017bE2193C9E24E);
uint8 public poolId;
address constant public rewards = address(0x453D4Ba9a2D594314DF88564248497F7D74d6b2C);
address constant public treasury = address(0x4A32De8c248533C28904b24B4cFCFE18E9F2ad01);
address public vault;
address public strategist;
uint constant public REWARDS_FEE = 665;
uint constant public CALL_FEE = 111;
uint constant public TREASURY_FEE = 112;
uint constant public STRATEGIST_FEE = 112;
uint constant public MAX_FEE = 1000;
uint constant public WITHDRAWAL_FEE = 10;
uint constant public WITHDRAWAL_MAX = 10000;
address[] public cakeToWbnbRoute = [cake, wbnb];
address[] public wbnbToBifiRoute = [wbnb, bifi];
address[] public cakeToLp0Route;
address[] public cakeToLp1Route;
event StratHarvest(address indexed harvester);
constructor(address _lpPair, uint8 _poolId, address _vault, address _strategist) public {
lpPair = _lpPair;
lpToken0 = IUniswapV2Pair(lpPair).token0();
lpToken1 = IUniswapV2Pair(lpPair).token1();
poolId = _poolId;
vault = _vault;
strategist = _strategist;
if (lpToken0 != cake) {
cakeToLp0Route = [cake, lpToken0];
}
if (lpToken1 != cake) {
cakeToLp1Route = [cake, lpToken1];
}
IERC20(lpPair).safeApprove(masterchef, uint(-1));
IERC20(cake).safeApprove(unirouter, uint(-1));
IERC20(wbnb).safeApprove(unirouter, uint(-1));
IERC20(lpToken0).safeApprove(unirouter, 0);
IERC20(lpToken0).safeApprove(unirouter, uint(-1));
IERC20(lpToken1).safeApprove(unirouter, 0);
IERC20(lpToken1).safeApprove(unirouter, uint(-1));
}
constructor(address _lpPair, uint8 _poolId, address _vault, address _strategist) public {
lpPair = _lpPair;
lpToken0 = IUniswapV2Pair(lpPair).token0();
lpToken1 = IUniswapV2Pair(lpPair).token1();
poolId = _poolId;
vault = _vault;
strategist = _strategist;
if (lpToken0 != cake) {
cakeToLp0Route = [cake, lpToken0];
}
if (lpToken1 != cake) {
cakeToLp1Route = [cake, lpToken1];
}
IERC20(lpPair).safeApprove(masterchef, uint(-1));
IERC20(cake).safeApprove(unirouter, uint(-1));
IERC20(wbnb).safeApprove(unirouter, uint(-1));
IERC20(lpToken0).safeApprove(unirouter, 0);
IERC20(lpToken0).safeApprove(unirouter, uint(-1));
IERC20(lpToken1).safeApprove(unirouter, 0);
IERC20(lpToken1).safeApprove(unirouter, uint(-1));
}
constructor(address _lpPair, uint8 _poolId, address _vault, address _strategist) public {
lpPair = _lpPair;
lpToken0 = IUniswapV2Pair(lpPair).token0();
lpToken1 = IUniswapV2Pair(lpPair).token1();
poolId = _poolId;
vault = _vault;
strategist = _strategist;
if (lpToken0 != cake) {
cakeToLp0Route = [cake, lpToken0];
}
if (lpToken1 != cake) {
cakeToLp1Route = [cake, lpToken1];
}
IERC20(lpPair).safeApprove(masterchef, uint(-1));
IERC20(cake).safeApprove(unirouter, uint(-1));
IERC20(wbnb).safeApprove(unirouter, uint(-1));
IERC20(lpToken0).safeApprove(unirouter, 0);
IERC20(lpToken0).safeApprove(unirouter, uint(-1));
IERC20(lpToken1).safeApprove(unirouter, 0);
IERC20(lpToken1).safeApprove(unirouter, uint(-1));
}
function deposit() public whenNotPaused {
uint256 pairBal = IERC20(lpPair).balanceOf(address(this));
if (pairBal > 0) {
IMasterChef(masterchef).deposit(poolId, pairBal);
}
}
function deposit() public whenNotPaused {
uint256 pairBal = IERC20(lpPair).balanceOf(address(this));
if (pairBal > 0) {
IMasterChef(masterchef).deposit(poolId, pairBal);
}
}
function withdraw(uint256 _amount) external {
require(msg.sender == vault, "!vault");
uint256 pairBal = IERC20(lpPair).balanceOf(address(this));
if (pairBal < _amount) {
IMasterChef(masterchef).withdraw(poolId, _amount.sub(pairBal));
pairBal = IERC20(lpPair).balanceOf(address(this));
}
if (pairBal > _amount) {
pairBal = _amount;
}
uint256 withdrawalFee = pairBal.mul(WITHDRAWAL_FEE).div(WITHDRAWAL_MAX);
IERC20(lpPair).safeTransfer(vault, pairBal.sub(withdrawalFee));
}
function withdraw(uint256 _amount) external {
require(msg.sender == vault, "!vault");
uint256 pairBal = IERC20(lpPair).balanceOf(address(this));
if (pairBal < _amount) {
IMasterChef(masterchef).withdraw(poolId, _amount.sub(pairBal));
pairBal = IERC20(lpPair).balanceOf(address(this));
}
if (pairBal > _amount) {
pairBal = _amount;
}
uint256 withdrawalFee = pairBal.mul(WITHDRAWAL_FEE).div(WITHDRAWAL_MAX);
IERC20(lpPair).safeTransfer(vault, pairBal.sub(withdrawalFee));
}
function withdraw(uint256 _amount) external {
require(msg.sender == vault, "!vault");
uint256 pairBal = IERC20(lpPair).balanceOf(address(this));
if (pairBal < _amount) {
IMasterChef(masterchef).withdraw(poolId, _amount.sub(pairBal));
pairBal = IERC20(lpPair).balanceOf(address(this));
}
if (pairBal > _amount) {
pairBal = _amount;
}
uint256 withdrawalFee = pairBal.mul(WITHDRAWAL_FEE).div(WITHDRAWAL_MAX);
IERC20(lpPair).safeTransfer(vault, pairBal.sub(withdrawalFee));
}
function harvest() external whenNotPaused {
require(!Address.isContract(msg.sender), "!contract");
IMasterChef(masterchef).deposit(poolId, 0);
chargeFees();
addLiquidity();
deposit();
emit StratHarvest(msg.sender);
}
function chargeFees() internal {
uint256 toWbnb = IERC20(cake).balanceOf(address(this)).mul(45).div(1000);
IUniswapRouterETH(unirouter).swapExactTokensForTokens(toWbnb, 0, cakeToWbnbRoute, address(this), now.add(600));
uint256 wbnbBal = IERC20(wbnb).balanceOf(address(this));
uint256 callFee = wbnbBal.mul(CALL_FEE).div(MAX_FEE);
IERC20(wbnb).safeTransfer(msg.sender, callFee);
uint256 treasuryHalf = wbnbBal.mul(TREASURY_FEE).div(MAX_FEE).div(2);
IERC20(wbnb).safeTransfer(treasury, treasuryHalf);
IUniswapRouterETH(unirouter).swapExactTokensForTokens(treasuryHalf, 0, wbnbToBifiRoute, treasury, now.add(600));
uint256 rewardsFee = wbnbBal.mul(REWARDS_FEE).div(MAX_FEE);
IERC20(wbnb).safeTransfer(rewards, rewardsFee);
uint256 strategistFee = wbnbBal.mul(STRATEGIST_FEE).div(MAX_FEE);
IERC20(wbnb).safeTransfer(strategist, strategistFee);
}
function addLiquidity() internal {
uint256 cakeHalf = IERC20(cake).balanceOf(address(this)).div(2);
if (lpToken0 != cake) {
IUniswapRouterETH(unirouter).swapExactTokensForTokens(cakeHalf, 0, cakeToLp0Route, address(this), now.add(600));
}
if (lpToken1 != cake) {
IUniswapRouterETH(unirouter).swapExactTokensForTokens(cakeHalf, 0, cakeToLp1Route, address(this), now.add(600));
}
uint256 lp0Bal = IERC20(lpToken0).balanceOf(address(this));
uint256 lp1Bal = IERC20(lpToken1).balanceOf(address(this));
IUniswapRouterETH(unirouter).addLiquidity(lpToken0, lpToken1, lp0Bal, lp1Bal, 1, 1, address(this), now.add(600));
}
function addLiquidity() internal {
uint256 cakeHalf = IERC20(cake).balanceOf(address(this)).div(2);
if (lpToken0 != cake) {
IUniswapRouterETH(unirouter).swapExactTokensForTokens(cakeHalf, 0, cakeToLp0Route, address(this), now.add(600));
}
if (lpToken1 != cake) {
IUniswapRouterETH(unirouter).swapExactTokensForTokens(cakeHalf, 0, cakeToLp1Route, address(this), now.add(600));
}
uint256 lp0Bal = IERC20(lpToken0).balanceOf(address(this));
uint256 lp1Bal = IERC20(lpToken1).balanceOf(address(this));
IUniswapRouterETH(unirouter).addLiquidity(lpToken0, lpToken1, lp0Bal, lp1Bal, 1, 1, address(this), now.add(600));
}
function addLiquidity() internal {
uint256 cakeHalf = IERC20(cake).balanceOf(address(this)).div(2);
if (lpToken0 != cake) {
IUniswapRouterETH(unirouter).swapExactTokensForTokens(cakeHalf, 0, cakeToLp0Route, address(this), now.add(600));
}
if (lpToken1 != cake) {
IUniswapRouterETH(unirouter).swapExactTokensForTokens(cakeHalf, 0, cakeToLp1Route, address(this), now.add(600));
}
uint256 lp0Bal = IERC20(lpToken0).balanceOf(address(this));
uint256 lp1Bal = IERC20(lpToken1).balanceOf(address(this));
IUniswapRouterETH(unirouter).addLiquidity(lpToken0, lpToken1, lp0Bal, lp1Bal, 1, 1, address(this), now.add(600));
}
function balanceOf() public view returns (uint256) {
return balanceOfLpPair().add(balanceOfPool());
}
function balanceOfLpPair() public view returns (uint256) {
return IERC20(lpPair).balanceOf(address(this));
}
function balanceOfPool() public view returns (uint256) {
(uint256 _amount, ) = IMasterChef(masterchef).userInfo(poolId, address(this));
return _amount;
}
function retireStrat() external {
require(msg.sender == vault, "!vault");
IMasterChef(masterchef).emergencyWithdraw(poolId);
uint256 pairBal = IERC20(lpPair).balanceOf(address(this));
IERC20(lpPair).transfer(vault, pairBal);
}
function panic() public onlyOwner {
pause();
IMasterChef(masterchef).emergencyWithdraw(poolId);
}
function pause() public onlyOwner {
_pause();
IERC20(lpPair).safeApprove(masterchef, 0);
IERC20(cake).safeApprove(unirouter, 0);
IERC20(wbnb).safeApprove(unirouter, 0);
IERC20(lpToken0).safeApprove(unirouter, 0);
IERC20(lpToken1).safeApprove(unirouter, 0);
}
function unpause() external onlyOwner {
_unpause();
IERC20(lpPair).safeApprove(masterchef, uint(-1));
IERC20(cake).safeApprove(unirouter, uint(-1));
IERC20(wbnb).safeApprove(unirouter, uint(-1));
IERC20(lpToken0).safeApprove(unirouter, 0);
IERC20(lpToken0).safeApprove(unirouter, uint(-1));
IERC20(lpToken1).safeApprove(unirouter, 0);
IERC20(lpToken1).safeApprove(unirouter, uint(-1));
}
function setStrategist(address _strategist) external {
require(msg.sender == strategist, "!strategist");
strategist = _strategist;
}
} | 11,169,497 | [
1,
13621,
434,
279,
6252,
358,
336,
16932,
628,
284,
4610,
310,
511,
52,
453,
8192,
316,
12913,
23780,
12521,
18,
12913,
23780,
12521,
353,
392,
18472,
690,
13667,
312,
6388,
261,
163,
227,
255,
2192,
49,
163,
227,
256,
13,
716,
5360,
2795,
2430,
358,
506,
431,
6703,
603,
326,
16827,
1359,
19656,
7824,
18,
2597,
353,
4797,
16,
19315,
438,
16,
471,
5360,
1281,
476,
358,
30891,
340,
18,
12913,
23780,
12521,
353,
279,
381,
310,
358,
506,
326,
404,
4501,
372,
24237,
2893,
603,
605,
2312,
18,
1220,
6252,
8616,
443,
917,
1282,
15098,
284,
19156,
518,
17024,
628,
326,
9229,
1368,
326,
3170,
13453,
39,
580,
74,
2845,
18,
6425,
6859,
283,
6397,
628,
17721,
4501,
372,
24237,
854,
10247,
2937,
3614,
11315,
6824,
16,
272,
1673,
471,
1416,
6437,
19,
3361,
18,
1021,
4656,
3082,
434,
7176,
854,
800,
9540,
471,
1898,
4501,
372,
2
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
] | [
1,
16351,
19736,
31089,
12136,
13352,
14461,
353,
14223,
6914,
16,
21800,
16665,
288,
203,
565,
1450,
14060,
654,
39,
3462,
364,
467,
654,
39,
3462,
31,
203,
565,
1450,
5267,
364,
1758,
31,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
203,
565,
1758,
5381,
1071,
17298,
6423,
273,
1758,
12,
20,
6114,
70,
24,
19728,
38,
29,
8876,
72,
5718,
38,
1611,
70,
40,
21,
71,
38,
69,
41,
15259,
22,
758,
6840,
72,
29,
31331,
13459,
5908,
25,
71,
1769,
203,
565,
1758,
5381,
1071,
276,
911,
273,
1758,
12,
20,
92,
20,
41,
5908,
29634,
9676,
9036,
38,
72,
23,
37,
323,
20,
69,
4033,
41,
6743,
1578,
21,
74,
40,
3437,
69,
3657,
73,
11861,
71,
41,
11149,
1769,
203,
565,
1758,
5381,
1071,
324,
704,
273,
1758,
12,
20,
14626,
69,
23,
42,
3361,
28,
38,
28,
73,
24,
40,
72,
7414,
22,
73,
41,
28,
8285,
37,
23,
29488,
6675,
6418,
23,
40,
3672,
37,
25,
30454,
37,
1769,
203,
565,
1758,
1071,
12423,
4154,
31,
203,
565,
1758,
1071,
12423,
1345,
20,
31,
203,
565,
1758,
1071,
12423,
1345,
21,
31,
203,
203,
565,
1758,
5381,
1071,
7738,
10717,
225,
273,
1758,
12,
20,
92,
6260,
74,
42,
22,
38,
20,
2290,
8148,
7950,
28,
37,
8642,
3361,
70,
2486,
13459,
24,
74,
29,
73,
3437,
69,
40,
72,
4848,
28,
39,
27,
42,
1769,
203,
565,
1758,
5381,
1071,
4171,
343,
10241,
273,
1758,
12,
20,
92,
9036,
3030,
7598,
21,
73,
41,
23,
2
] |
pragma solidity ^0.4.24;
/*
* gibmireinbier - Full Stack Blockchain Developer
* 0xA4a799086aE18D7db6C4b57f496B081b44888888
* [email protected]
*/
/*
CHANGELOGS:
. GrandPot : 2 rewards per round
5% pot with winner rate 100%,
no dividends, no fund to F2M contract
15% pot with winner rate dynamic, init at 1st round with rate = ((initGrandPot * 2 * 100 / 68) * avgMul / SLP) + 1000;
push 12% to F2M contract (10% dividends, 2% fund) => everybody happy! // --REMOVED
if total tickets > rate then 100% got winner
no winner : increased in the next round
got winner : decreased in the next round
. Bounty : received 30% bought tickets of bountyhunter back in the next round instead of ETH
(bonus tickets not included)
. SBountys : received 10% bought tickets of sbountyhunter back in the next round instead of ETH
(bonus tickets not included)
claimable only in pending time between 2 rounds
. 1% bought tickets as bonus to next round (1st buy turn)
(bonus Tickets not included)
. Jackpot: rates increased from (1/Rate1, 1/Rate2) to (1/(Rate1 - 1), 1/(Rate2 - 1)) after each buy
and reseted if jackpot triggered.
jackpot rate = (ethAmount / 0.1) * rate, max winrate = 1/2
no dividends, no fund to F2M contract
. Ticketsnumbers start from 1 in every rounds
. Multiplier system:
. all tickets got same weight = 1
. 2 decimals in stead of 0
. Multi = (grandPot / initGrandPot) * x * y * z
x = (11 - timer1) / 4 + 1 (unit = hour(s), max = 15/4)
timer1 updated real time, but x got delay 60 seconds from last buy
y = (6 - timer2) / 3 + 1 (unit = day(s), max = 3)
z = 4 if isGoldenMin, else 1
GOLDEN MINUTE : realTime, set = 8 atm
that means from x: 08 : 00 to x:08:59 is goldenMin and z = 4
. Waiting time between 2 rounds 24 hours -> 18 hours
. addPot :
80% -> grandPot
10% -> majorPot
10% -> minorPot
BUGS FIXED:
. Jackpot rate increased with multi = ethAmount / 0.1 (ether)
no more split buy required
. GrandPot getWeightRange() problems
AUTHORS:
. Seizo :
Tickets bonus per 100 tickets,
setLastRound anytime
remove pushDividend when grandPot, jackpot triggered, called only on tickets buying
remove round0
. Clark : Multiplier system
0xd9cd43AD9cD04183b5083E9E6c8DD0CE0c08eDe3
. GMEB : Tickets bounty system, Math. formulas
0xA4a799086aE18D7db6C4b57f496B081b44888888
. Kuroo Hazama : Dynamic rate
0x1E55fa952FCBc1f917746277C9C99cf65D53EbC8
*/
library Helper {
using SafeMath for uint256;
uint256 constant public ZOOM = 1000;
uint256 constant public SDIVIDER = 3450000;
uint256 constant public PDIVIDER = 3450000;
uint256 constant public RDIVIDER = 1580000;
// Starting LS price (SLP)
uint256 constant public SLP = 0.002 ether;
// Starting Added Time (SAT)
uint256 constant public SAT = 30; // seconds
// Price normalization (PN)
uint256 constant public PN = 777;
// EarlyIncome base
uint256 constant public PBASE = 13;
uint256 constant public PMULTI = 26;
uint256 constant public LBase = 1;
uint256 constant public ONE_HOUR = 3600;
uint256 constant public ONE_DAY = 24 * ONE_HOUR;
//uint256 constant public TIMEOUT0 = 3 * ONE_HOUR;
uint256 constant public TIMEOUT1 = 12 * ONE_HOUR;
uint256 constant public TIMEOUT2 = 7 * ONE_DAY;
function bytes32ToString (bytes32 data)
public
pure
returns (string)
{
bytes memory bytesString = new bytes(32);
for (uint j=0; j<32; j++) {
byte char = byte(bytes32(uint(data) * 2 ** (8 * j)));
if (char != 0) {
bytesString[j] = char;
}
}
return string(bytesString);
}
function uintToBytes32(uint256 n)
public
pure
returns (bytes32)
{
return bytes32(n);
}
function bytes32ToUint(bytes32 n)
public
pure
returns (uint256)
{
return uint256(n);
}
function stringToBytes32(string memory source)
public
pure
returns (bytes32 result)
{
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function stringToUint(string memory source)
public
pure
returns (uint256)
{
return bytes32ToUint(stringToBytes32(source));
}
function uintToString(uint256 _uint)
public
pure
returns (string)
{
return bytes32ToString(uintToBytes32(_uint));
}
/*
function getSlice(uint256 begin, uint256 end, string text) public pure returns (string) {
bytes memory a = new bytes(end-begin+1);
for(uint i = 0; i <= end - begin; i++){
a[i] = bytes(text)[i + begin - 1];
}
return string(a);
}
*/
function validUsername(string _username)
public
pure
returns(bool)
{
uint256 len = bytes(_username).length;
// Im Raum [4, 18]
if ((len < 4) || (len > 18)) return false;
// Letzte Char != ' '
if (bytes(_username)[len-1] == 32) return false;
// Erste Char != '0'
return uint256(bytes(_username)[0]) != 48;
}
// Lottery Helper
// Seconds added per LT = SAT - ((Current no. of LT + 1) / SDIVIDER)^6
function getAddedTime(uint256 _rTicketSum, uint256 _tAmount)
public
pure
returns (uint256)
{
//Luppe = 10000 = 10^4
uint256 base = (_rTicketSum + 1).mul(10000) / SDIVIDER;
uint256 expo = base;
expo = expo.mul(expo).mul(expo); // ^3
expo = expo.mul(expo); // ^6
// div 10000^6
expo = expo / (10**24);
if (expo > SAT) return 0;
return (SAT - expo).mul(_tAmount);
}
function getNewEndTime(uint256 toAddTime, uint256 slideEndTime, uint256 fixedEndTime)
public
view
returns(uint256)
{
uint256 _slideEndTime = (slideEndTime).add(toAddTime);
uint256 timeout = _slideEndTime.sub(block.timestamp);
// timeout capped at TIMEOUT1
if (timeout > TIMEOUT1) timeout = TIMEOUT1;
_slideEndTime = (block.timestamp).add(timeout);
// Capped at fixedEndTime
if (_slideEndTime > fixedEndTime) return fixedEndTime;
return _slideEndTime;
}
// get random in range [1, _range] with _seed
function getRandom(uint256 _seed, uint256 _range)
public
pure
returns(uint256)
{
if (_range == 0) return _seed;
return (_seed % _range) + 1;
}
function getEarlyIncomeMul(uint256 _ticketSum)
public
pure
returns(uint256)
{
// Early-Multiplier = 1 + PBASE / (1 + PMULTI * ((Current No. of LT)/RDIVIDER)^6)
uint256 base = _ticketSum * ZOOM / RDIVIDER;
uint256 expo = base.mul(base).mul(base); //^3
expo = expo.mul(expo) / (ZOOM**6); //^6
return (1 + PBASE / (1 + expo.mul(PMULTI)));
}
// get reveiced Tickets, based on current round ticketSum
function getTAmount(uint256 _ethAmount, uint256 _ticketSum)
public
pure
returns(uint256)
{
uint256 _tPrice = getTPrice(_ticketSum);
return _ethAmount.div(_tPrice);
}
function isGoldenMin(
uint256 _slideEndTime
)
public
view
returns(bool)
{
uint256 _restTime1 = _slideEndTime.sub(block.timestamp);
// golden min. exist if timer1 < 6 hours
if (_restTime1 > 6 hours) return false;
uint256 _min = (block.timestamp / 60) % 60;
return _min == 8;
}
// percent ZOOM = 100, ie. mul = 2.05 return 205
// Lotto-Multiplier = ((grandPot / initGrandPot)^2) * x * y * z
// x = (TIMEOUT1 - timer1 - 1) / 4 + 1 => (unit = hour, max = 11/4 + 1 = 3.75)
// y = (TIMEOUT2 - timer2 - 1) / 3 + 1) => (unit = day max = 3)
// z = isGoldenMin ? 4 : 1
function getTMul(
uint256 _initGrandPot,
uint256 _grandPot,
uint256 _slideEndTime,
uint256 _fixedEndTime
)
public
view
returns(uint256)
{
uint256 _pZoom = 100;
uint256 base = _initGrandPot != 0 ?_pZoom.mul(_grandPot) / _initGrandPot : _pZoom;
uint256 expo = base.mul(base);
uint256 _timer1 = _slideEndTime.sub(block.timestamp) / 1 hours; // 0.. 11
uint256 _timer2 = _fixedEndTime.sub(block.timestamp) / 1 days; // 0 .. 6
uint256 x = (_pZoom * (11 - _timer1) / 4) + _pZoom; // [1, 3.75]
uint256 y = (_pZoom * (6 - _timer2) / 3) + _pZoom; // [1, 3]
uint256 z = isGoldenMin(_slideEndTime) ? 4 : 1;
uint256 res = expo.mul(x).mul(y).mul(z) / (_pZoom ** 3); // ~ [1, 90]
return res;
}
// get ticket price, based on current round ticketSum
//unit in ETH, no need / zoom^6
function getTPrice(uint256 _ticketSum)
public
pure
returns(uint256)
{
uint256 base = (_ticketSum + 1).mul(ZOOM) / PDIVIDER;
uint256 expo = base;
expo = expo.mul(expo).mul(expo); // ^3
expo = expo.mul(expo); // ^6
uint256 tPrice = SLP + expo / PN;
return tPrice;
}
// used to draw grandpot results
// weightRange = roundWeight * grandpot / (grandpot - initGrandPot)
// grandPot = initGrandPot + round investedSum(for grandPot)
function getWeightRange(uint256 initGrandPot)
public
pure
returns(uint256)
{
uint256 avgMul = 30;
return ((initGrandPot * 2 * 100 / 68) * avgMul / SLP) + 1000;
}
// dynamic rate _RATE = n
// major rate = 1/n with _RATE = 1000 999 ... 1
// minor rate = 1/n with _RATE = 500 499 ... 1
// loop = _ethAmount / _MIN
// lose rate = ((n- 1) / n) * ((n- 2) / (n - 1)) * ... * ((n- k) / (n - k + 1)) = (n - k) / n
function isJackpot(
uint256 _seed,
uint256 _RATE,
uint256 _MIN,
uint256 _ethAmount
)
public
pure
returns(bool)
{
// _RATE >= 2
uint256 k = _ethAmount / _MIN;
if (k == 0) return false;
// LOSE RATE MIN 50%, WIN RATE MAX 50%
uint256 _loseCap = _RATE / 2;
// IF _RATE - k > _loseCap
if (_RATE > k + _loseCap) _loseCap = _RATE - k;
bool _lose = (_seed % _RATE) < _loseCap;
return !_lose;
}
}
contract Lottery {
using SafeMath for uint256;
modifier withdrawRight(){
require(msg.sender == address(bankContract), "Bank only");
_;
}
modifier onlyDevTeam() {
require(msg.sender == devTeam, "only for development team");
_;
}
modifier buyable() {
require(block.timestamp > round[curRoundId].startTime, "not ready to sell Ticket");
require(block.timestamp < round[curRoundId].slideEndTime, "round over");
require(block.number <= round[curRoundId].keyBlockNr, "round over");
_;
}
modifier notStarted() {
require(block.timestamp < round[curRoundId].startTime, "round started");
_;
}
enum RewardType {
Minor,
Major,
Grand,
Bounty
}
// 1 buy = 1 slot = _ethAmount => (tAmount, tMul)
struct Slot {
address buyer;
uint256 rId;
// ticket numbers in range and unique in all rounds
uint256 tNumberFrom;
uint256 tNumberTo;
uint256 ethAmount;
uint256 salt;
}
struct Round {
// earlyIncome weight sum
uint256 rEarlyIncomeWeight;
// blockNumber to get hash as random seed
uint256 keyBlockNr;
mapping(address => bool) pBonusReceived;
mapping(address => uint256) pBoughtTicketSum;
mapping(address => uint256) pTicketSum;
mapping(address => uint256) pInvestedSum;
// early income weight by address
mapping(address => uint256) pEarlyIncomeWeight;
mapping(address => uint256) pEarlyIncomeCredit;
mapping(address => uint256) pEarlyIncomeClaimed;
// early income per weight
uint256 ppw;
// endTime increased every slot sold
// endTime limited by fixedEndTime
uint256 startTime;
uint256 slideEndTime;
uint256 fixedEndTime;
// ticketSum from round 1 to this round
uint256 ticketSum;
// investedSum from round 1 to this round
uint256 investedSum;
// number of slots from round 1 to this round
uint256 slotSum;
}
// round started with this grandPot amount,
// used to calculate the rate for grandPot results
// init in roundInit function
uint256 public initGrandPot;
Slot[] public slot;
// slotId logs by address
mapping( address => uint256[]) pSlot;
mapping( address => uint256) public pSlotSum;
// logs by address
mapping( address => uint256) public pTicketSum;
mapping( address => uint256) public pInvestedSum;
CitizenInterface public citizenContract;
F2mInterface public f2mContract;
BankInterface public bankContract;
RewardInterface public rewardContract;
address public devTeam;
uint256 constant public ZOOM = 1000;
uint256 constant public ONE_HOUR = 60 * 60;
uint256 constant public ONE_DAY = 24 * ONE_HOUR;
uint256 constant public TIMEOUT0 = 3 * ONE_HOUR;
uint256 constant public TIMEOUT1 = 12 * ONE_HOUR;
uint256 constant public TIMEOUT2 = 7 * ONE_DAY;
uint256 constant public FINALIZE_WAIT_DURATION = 60; // 60 Seconds
uint256 constant public NEWROUND_WAIT_DURATION = 18 * ONE_HOUR; // 24 Hours
// 15 seconds on Ethereum, 12 seconds used instead to make sure blockHash unavaiable
// when slideEndTime reached
// keyBlockNumber will be estimated again after every slot buy
uint256 constant public BLOCK_TIME = 12;
uint256 constant public MAX_BLOCK_DISTANCE = 250;
uint256 constant public TBONUS_RATE = 100;
uint256 public CASHOUT_REQ = 1;
uint256 public GRAND_RATE;
uint256 public MAJOR_RATE = 1001;
uint256 public MINOR_RATE = 501;
uint256 constant public MAJOR_MIN = 0.1 ether;
uint256 constant public MINOR_MIN = 0.1 ether;
//Bonus Tickets : Bounty + 7 sBounty
uint256 public bountyPercent = 30;
uint256 public sBountyPercent = 10;
//uint256 public toNextPotPercent = 27;
uint256 public grandRewardPercent = 15;
uint256 public sGrandRewardPercent = 5;
uint256 public jRewardPercent = 60;
uint256 public toTokenPercent = 12; // 10% dividends 2% fund
uint256 public toBuyTokenPercent = 1;
uint256 public earlyIncomePercent = 22;
uint256 public toRefPercent = 15;
// sum == 100% = toPotPercent/100 * investedSum
// uint256 public grandPercent = 80; //68;
uint256 public majorPercent = 10; // 24;
uint256 public minorPercent = 10; // 8;
uint256 public grandPot;
uint256 public majorPot;
uint256 public minorPot;
uint256 public curRoundId;
uint256 public lastRoundId = 88888888;
mapping (address => uint256) public rewardBalance;
// used to save gas on earlyIncome calculating, curRoundId never included
// only earlyIncome from round 1st to curRoundId-1 are fixed
mapping (address => uint256) public lastWithdrawnRound;
mapping (address => uint256) public earlyIncomeScannedSum;
mapping (uint256 => Round) public round;
// Current Round
// first SlotId in last Block to fire jackpot
uint256 public jSlot;
// jackpot results of all slots in same block will be drawed at the same time,
// by player, who buys the first slot in next block
uint256 public lastBlockNr;
// added by slot salt after every slot buy
// does not matter with overflow
uint256 public curRSalt;
// ticket sum of current round
uint256 public curRTicketSum;
uint256 public lastBuyTime;
uint256 public lastEndTime;
uint256 constant multiDelayTime = 60;
constructor (address _devTeam)
public
{
// register address in network
DevTeamInterface(_devTeam).setLotteryAddress(address(this));
devTeam = _devTeam;
}
// _contract = [f2mAddress, bankAddress, citizenAddress, lotteryAddress, rewardAddress, whitelistAddress];
function joinNetwork(address[6] _contract)
public
{
require(address(citizenContract) == 0x0,"already setup");
f2mContract = F2mInterface(_contract[0]);
bankContract = BankInterface(_contract[1]);
citizenContract = CitizenInterface(_contract[2]);
//lotteryContract = LotteryInterface(lotteryAddress);
rewardContract = RewardInterface(_contract[4]);
}
function activeFirstRound()
public
onlyDevTeam()
{
require(curRoundId == 0, "already activated");
initRound();
GRAND_RATE = getWeightRange();
}
// Core Functions
function pushToPot()
public
payable
{
addPot(msg.value);
}
function checkpoint()
private
{
// dummy slot between every 2 rounds
// dummy slot never win jackpot cause of min 0.1 ETH
Slot memory _slot;
// _slot.tNumberTo = round[curRoundId].ticketSum;
slot.push(_slot);
Round memory _round;
_round.startTime = NEWROUND_WAIT_DURATION.add(block.timestamp);
// started with 3 hours timeout
_round.slideEndTime = TIMEOUT0 + _round.startTime;
_round.fixedEndTime = TIMEOUT2 + _round.startTime;
_round.keyBlockNr = genEstKeyBlockNr(_round.slideEndTime);
_round.ticketSum = round[curRoundId].ticketSum;
_round.investedSum = round[curRoundId].investedSum;
_round.slotSum = slot.length;
curRoundId = curRoundId + 1;
round[curRoundId] = _round;
initGrandPot = grandPot;
curRTicketSum = 0;
}
// from round 28+ function -- REMOVED
function isLastRound()
public
view
returns(bool)
{
return (curRoundId == lastRoundId);
}
function goNext()
private
{
grandPot = 0;
majorPot = 0;
minorPot = 0;
f2mContract.pushDividends.value(this.balance)();
// never start
round[curRoundId].startTime = block.timestamp * 10;
round[curRoundId].slideEndTime = block.timestamp * 10 + 1;
CASHOUT_REQ = 0;
}
function initRound()
private
{
// update all Round Log
checkpoint();
if (isLastRound()) goNext();
updateMulti();
}
function finalizeable()
public
view
returns(bool)
{
uint256 finalizeTime = FINALIZE_WAIT_DURATION.add(round[curRoundId].slideEndTime);
if (finalizeTime > block.timestamp) return false; // too soon to finalize
if (getEstKeyBlockNr(curRoundId) >= block.number) return false; //block hash not exist
return curRoundId > 0;
}
// bounty
function finalize()
public
{
require(finalizeable(), "Not ready to draw results");
uint256 _pRoundTicketSum = round[curRoundId].pBoughtTicketSum[msg.sender];
uint256 _bountyTicketSum = _pRoundTicketSum * bountyPercent / 100;
endRound(msg.sender, _bountyTicketSum);
initRound();
mintSlot(msg.sender, _bountyTicketSum, 0, 0);
}
function mintReward(
address _lucker,
uint256 _winNr,
uint256 _slotId,
uint256 _value,
RewardType _rewardType)
private
{
// add reward balance if its not Bounty Type and winner != 0x0
if ((_rewardType != RewardType.Bounty) && (_lucker != 0x0))
rewardBalance[_lucker] = rewardBalance[_lucker].add(_value);
// reward log
rewardContract.mintReward(
_lucker,
curRoundId,
_winNr,
slot[_slotId].tNumberFrom,
slot[_slotId].tNumberTo,
_value,
uint256(_rewardType)
);
}
function mintSlot(
address _buyer,
// uint256 _rId,
// ticket numbers in range and unique in all rounds
// uint256 _tNumberFrom,
// uint256 _tNumberTo,
uint256 _tAmount,
uint256 _ethAmount,
uint256 _salt
)
private
{
uint256 _tNumberFrom = curRTicketSum + 1;
uint256 _tNumberTo = _tNumberFrom + _tAmount - 1;
Slot memory _slot;
_slot.buyer = _buyer;
_slot.rId = curRoundId;
_slot.tNumberFrom = _tNumberFrom;
_slot.tNumberTo = _tNumberTo;
_slot.ethAmount = _ethAmount;
_slot.salt = _salt;
slot.push(_slot);
updateTicketSum(_buyer, _tAmount);
round[curRoundId].slotSum = slot.length;
pSlot[_buyer].push(slot.length - 1);
}
function jackpot()
private
{
// get blocknumber to get blockhash
uint256 keyBlockNr = getKeyBlockNr(lastBlockNr);//block.number;
// salt not effected by jackpot, too risk
uint256 seed = getSeed(keyBlockNr);
// slot numberic from 1 ... totalSlot(round)
// jackpot for all slot in last block, jSlot <= i <= lastSlotId (=slotSum - 1)
// _to = first Slot in new block
//uint256 _to = round[curRoundId].slotSum;
uint256 jReward;
// uint256 toF2mAmount;
address winner;
// jackpot check for slots in last block
while (jSlot + 1 < round[curRoundId].slotSum) {
// majorPot
if (MAJOR_RATE > 2) MAJOR_RATE--;
if (Helper.isJackpot(seed, MAJOR_RATE, MAJOR_MIN, slot[jSlot].ethAmount)){
winner = slot[jSlot].buyer;
jReward = majorPot / 100 * jRewardPercent;
mintReward(winner, 0, jSlot, jReward, RewardType.Major);
majorPot = majorPot - jReward;
MAJOR_RATE = 1001;
}
seed = seed + jSlot;
// minorPot
if (MINOR_RATE > 2) MINOR_RATE--;
if (Helper.isJackpot(seed, MINOR_RATE, MINOR_MIN, slot[jSlot].ethAmount)){
winner = slot[jSlot].buyer;
jReward = minorPot / 100 * jRewardPercent;
mintReward(winner, 0, jSlot, jReward, RewardType.Minor);
minorPot = minorPot - jReward;
MINOR_RATE = 501;
}
seed = seed + jSlot;
jSlot++;
}
}
function endRound(address _bountyHunter, uint256 _bountyTicketSum)
private
{
// GRAND_RATE = GRAND_RATE * 9 / 10; // REMOVED
uint256 _rId = curRoundId;
uint256 keyBlockNr = getKeyBlockNr(round[_rId].keyBlockNr);
// curRSalt SAFE, CHECKED
uint256 _seed = getSeed(keyBlockNr) + curRSalt;
uint256 onePercent = grandPot / 100;
// 0 : 5% grandPot, 100% winRate
// 1 : 15% grandPot, dynamic winRate
uint256[2] memory rGrandReward = [
onePercent * sGrandRewardPercent,
onePercent * grandRewardPercent
];
uint256[2] memory weightRange = [
curRTicketSum,
GRAND_RATE > curRTicketSum ? GRAND_RATE : curRTicketSum
];
// REMOVED
// uint256[2] memory toF2mAmount = [0, onePercent * toTokenPercent];
// 1st turn for small grandPot (val = 5% rate = 100%)
// 2nd turn for big grandPot (val = 15%, rate = max(GRAND_RATE, curRTicketSum), 12% to F2M contract if got winner)
for (uint256 i = 0; i < 2; i++){
address _winner = 0x0;
uint256 _winSlot = 0;
uint256 _winNr = Helper.getRandom(_seed, weightRange[i]);
// if winNr > curRTicketSum => no winner this turn
// win Slot : fromWeight <= winNr <= toWeight
// got winner this rolling turn
if (_winNr <= curRTicketSum) {
// grandPot -= rGrandReward[i] + toF2mAmount[i];
grandPot -= rGrandReward[i];
// big grandPot 15%
if (i == 1) {
GRAND_RATE = GRAND_RATE * 2;
// f2mContract.pushDividends.value(toF2mAmount[i])();
}
_winSlot = getWinSlot(_winNr);
_winner = slot[_winSlot].buyer;
_seed = _seed + (_seed / 10);
}
mintReward(_winner, _winNr, _winSlot, rGrandReward[i], RewardType.Grand);
}
mintReward(_bountyHunter, 0, 0, _bountyTicketSum, RewardType.Bounty);
rewardContract.resetCounter(curRoundId);
GRAND_RATE = (GRAND_RATE / 100) * 99 + 1;
}
function buy(string _sSalt)
public
payable
{
buyFor(_sSalt, msg.sender);
}
function updateInvested(address _buyer, uint256 _ethAmount)
private
{
round[curRoundId].investedSum += _ethAmount;
round[curRoundId].pInvestedSum[_buyer] += _ethAmount;
pInvestedSum[_buyer] += _ethAmount;
}
function updateTicketSum(address _buyer, uint256 _tAmount)
private
{
round[curRoundId].ticketSum = round[curRoundId].ticketSum + _tAmount;
round[curRoundId].pTicketSum[_buyer] = round[curRoundId].pTicketSum[_buyer] + _tAmount;
curRTicketSum = curRTicketSum + _tAmount;
pTicketSum[_buyer] = pTicketSum[_buyer] + _tAmount;
}
function updateEarlyIncome(address _buyer, uint256 _pWeight)
private
{
round[curRoundId].rEarlyIncomeWeight = _pWeight.add(round[curRoundId].rEarlyIncomeWeight);
round[curRoundId].pEarlyIncomeWeight[_buyer] = _pWeight.add(round[curRoundId].pEarlyIncomeWeight[_buyer]);
round[curRoundId].pEarlyIncomeCredit[_buyer] = round[curRoundId].pEarlyIncomeCredit[_buyer].add(_pWeight.mul(round[curRoundId].ppw));
}
function getBonusTickets(address _buyer)
private
returns(uint256)
{
if (round[curRoundId].pBonusReceived[_buyer]) return 0;
round[curRoundId].pBonusReceived[_buyer] = true;
return round[curRoundId - 1].pBoughtTicketSum[_buyer] / TBONUS_RATE;
}
function updateMulti()
private
{
if (lastBuyTime + multiDelayTime < block.timestamp) {
lastEndTime = round[curRoundId].slideEndTime;
}
lastBuyTime = block.timestamp;
}
function buyFor(string _sSalt, address _sender)
public
payable
buyable()
{
uint256 _salt = Helper.stringToUint(_sSalt);
uint256 _ethAmount = msg.value;
uint256 _ticketSum = curRTicketSum;
require(_ethAmount >= Helper.getTPrice(_ticketSum), "not enough to buy 1 ticket");
// investedSum logs
updateInvested(_sender, _ethAmount);
updateMulti();
// update salt
curRSalt = curRSalt + _salt;
uint256 _tAmount = Helper.getTAmount(_ethAmount, _ticketSum);
uint256 _tMul = getTMul(); // 100x Zoomed
uint256 _pMul = Helper.getEarlyIncomeMul(_ticketSum);
uint256 _pWeight = _pMul.mul(_tAmount);
uint256 _toAddTime = Helper.getAddedTime(_ticketSum, _tAmount);
addTime(curRoundId, _toAddTime);
_tAmount = _tAmount.mul(_tMul) / 100;
round[curRoundId].pBoughtTicketSum[_sender] += _tAmount;
mintSlot(_sender, _tAmount + getBonusTickets(_sender), _ethAmount, _salt);
// EarlyIncome Weight
// ppw and credit zoomed x1000
// earlyIncome mul of each ticket in this slot
updateEarlyIncome(_sender, _pWeight);
// first slot in this block draw jacpot results for
// all slot in last block
if (lastBlockNr != block.number) {
jackpot();
lastBlockNr = block.number;
}
distributeSlotBuy(_sender, curRoundId, _ethAmount);
round[curRoundId].keyBlockNr = genEstKeyBlockNr(round[curRoundId].slideEndTime);
}
function distributeSlotBuy(address _sender, uint256 _rId, uint256 _ethAmount)
private
{
uint256 onePercent = _ethAmount / 100;
uint256 toF2mAmount = onePercent * toTokenPercent; // 12
uint256 toRefAmount = onePercent * toRefPercent; // 10
uint256 toBuyTokenAmount = onePercent * toBuyTokenPercent; //1
uint256 earlyIncomeAmount = onePercent * earlyIncomePercent; //27
uint256 taxAmount = toF2mAmount + toRefAmount + toBuyTokenAmount + earlyIncomeAmount; // 50
uint256 taxedEthAmount = _ethAmount.sub(taxAmount); // 50
addPot(taxedEthAmount);
// 10% Ref
citizenContract.pushRefIncome.value(toRefAmount)(_sender);
// 2% Fund + 10% Dividends
f2mContract.pushDividends.value(toF2mAmount)();
// 1% buy Token
f2mContract.buyFor.value(toBuyTokenAmount)(_sender);
// 27% Early
uint256 deltaPpw = (earlyIncomeAmount * ZOOM).div(round[_rId].rEarlyIncomeWeight);
round[_rId].ppw = deltaPpw.add(round[_rId].ppw);
}
function claimEarlyIncomebyAddress(address _buyer)
private
{
if (curRoundId == 0) return;
claimEarlyIncomebyAddressRound(_buyer, curRoundId);
uint256 _rId = curRoundId - 1;
while ((_rId > lastWithdrawnRound[_buyer]) && (_rId + 20 > curRoundId)) {
earlyIncomeScannedSum[_buyer] += claimEarlyIncomebyAddressRound(_buyer, _rId);
_rId = _rId - 1;
}
}
function claimEarlyIncomebyAddressRound(address _buyer, uint256 _rId)
private
returns(uint256)
{
uint256 _amount = getCurEarlyIncomeByAddressRound(_buyer, _rId);
if (_amount == 0) return 0;
round[_rId].pEarlyIncomeClaimed[_buyer] = _amount.add(round[_rId].pEarlyIncomeClaimed[_buyer]);
rewardBalance[_buyer] = _amount.add(rewardBalance[_buyer]);
return _amount;
}
function withdrawFor(address _sender)
public
withdrawRight()
returns(uint256)
{
if (curRoundId == 0) return;
claimEarlyIncomebyAddress(_sender);
lastWithdrawnRound[_sender] = curRoundId - 1;
uint256 _amount = rewardBalance[_sender];
rewardBalance[_sender] = 0;
bankContract.pushToBank.value(_amount)(_sender);
return _amount;
}
function addTime(uint256 _rId, uint256 _toAddTime)
private
{
round[_rId].slideEndTime = Helper.getNewEndTime(_toAddTime, round[_rId].slideEndTime, round[_rId].fixedEndTime);
}
// distribute to 3 pots Grand, Majorm Minor
function addPot(uint256 _amount)
private
{
uint256 onePercent = _amount / 100;
uint256 toMinor = onePercent * minorPercent;
uint256 toMajor = onePercent * majorPercent;
uint256 toGrand = _amount - toMinor - toMajor;
minorPot = minorPot + toMinor;
majorPot = majorPot + toMajor;
grandPot = grandPot + toGrand;
}
//////////////////////////////////////////////////////////////////
// READ FUNCTIONS
//////////////////////////////////////////////////////////////////
function isWinSlot(uint256 _slotId, uint256 _keyNumber)
public
view
returns(bool)
{
return (slot[_slotId - 1].tNumberTo < _keyNumber) && (slot[_slotId].tNumberTo >= _keyNumber);
}
function getWeightRange()
public
view
returns(uint256)
{
return Helper.getWeightRange(initGrandPot);
}
function getWinSlot(uint256 _keyNumber)
public
view
returns(uint256)
{
// return 0 if not found
uint256 _to = slot.length - 1;
uint256 _from = round[curRoundId-1].slotSum + 1; // dummy slot ignore
uint256 _pivot;
//Slot memory _slot;
uint256 _pivotTo;
// Binary search
while (_from <= _to) {
_pivot = (_from + _to) / 2;
_pivotTo = slot[_pivot].tNumberTo;
if (isWinSlot(_pivot, _keyNumber)) return _pivot;
if (_pivotTo < _keyNumber) { // in right side
_from = _pivot + 1;
} else { // in left side
_to = _pivot - 1;
}
}
return _pivot; // never happens or smt gone wrong
}
// Key Block in future
function genEstKeyBlockNr(uint256 _endTime)
public
view
returns(uint256)
{
if (block.timestamp >= _endTime) return block.number + 8;
uint256 timeDist = _endTime - block.timestamp;
uint256 estBlockDist = timeDist / BLOCK_TIME;
return block.number + estBlockDist + 8;
}
// get block hash of first block with blocktime > _endTime
function getSeed(uint256 _keyBlockNr)
public
view
returns (uint256)
{
// Key Block not mined atm
if (block.number <= _keyBlockNr) return block.number;
return uint256(blockhash(_keyBlockNr));
}
// current reward balance
function getRewardBalance(address _buyer)
public
view
returns(uint256)
{
return rewardBalance[_buyer];
}
// GET endTime
function getSlideEndTime(uint256 _rId)
public
view
returns(uint256)
{
return(round[_rId].slideEndTime);
}
function getFixedEndTime(uint256 _rId)
public
view
returns(uint256)
{
return(round[_rId].fixedEndTime);
}
function getTotalPot()
public
view
returns(uint256)
{
return grandPot + majorPot + minorPot;
}
// EarlyIncome
function getEarlyIncomeByAddress(address _buyer)
public
view
returns(uint256)
{
uint256 _sum = earlyIncomeScannedSum[_buyer];
uint256 _fromRound = lastWithdrawnRound[_buyer] + 1; // >=1
if (_fromRound + 100 < curRoundId) _fromRound = curRoundId - 100;
uint256 _rId = _fromRound;
while (_rId <= curRoundId) {
_sum = _sum + getEarlyIncomeByAddressRound(_buyer, _rId);
_rId++;
}
return _sum;
}
// included claimed amount
function getEarlyIncomeByAddressRound(address _buyer, uint256 _rId)
public
view
returns(uint256)
{
uint256 _pWeight = round[_rId].pEarlyIncomeWeight[_buyer];
uint256 _ppw = round[_rId].ppw;
uint256 _rCredit = round[_rId].pEarlyIncomeCredit[_buyer];
uint256 _rEarlyIncome = ((_ppw.mul(_pWeight)).sub(_rCredit)).div(ZOOM);
return _rEarlyIncome;
}
function getCurEarlyIncomeByAddress(address _buyer)
public
view
returns(uint256)
{
uint256 _sum = 0;
uint256 _fromRound = lastWithdrawnRound[_buyer] + 1; // >=1
if (_fromRound + 100 < curRoundId) _fromRound = curRoundId - 100;
uint256 _rId = _fromRound;
while (_rId <= curRoundId) {
_sum = _sum.add(getCurEarlyIncomeByAddressRound(_buyer, _rId));
_rId++;
}
return _sum;
}
function getCurEarlyIncomeByAddressRound(address _buyer, uint256 _rId)
public
view
returns(uint256)
{
uint256 _rEarlyIncome = getEarlyIncomeByAddressRound(_buyer, _rId);
return _rEarlyIncome.sub(round[_rId].pEarlyIncomeClaimed[_buyer]);
}
////////////////////////////////////////////////////////////////////
function getEstKeyBlockNr(uint256 _rId)
public
view
returns(uint256)
{
return round[_rId].keyBlockNr;
}
function getKeyBlockNr(uint256 _estKeyBlockNr)
public
view
returns(uint256)
{
require(block.number > _estKeyBlockNr, "blockHash not avaiable");
uint256 jump = (block.number - _estKeyBlockNr) / MAX_BLOCK_DISTANCE * MAX_BLOCK_DISTANCE;
return _estKeyBlockNr + jump;
}
// Logs
function getCurRoundId()
public
view
returns(uint256)
{
return curRoundId;
}
function getTPrice()
public
view
returns(uint256)
{
return Helper.getTPrice(curRTicketSum);
}
function getTMul()
public
view
returns(uint256)
{
return Helper.getTMul(
initGrandPot,
grandPot,
lastBuyTime + multiDelayTime < block.timestamp ? round[curRoundId].slideEndTime : lastEndTime,
round[curRoundId].fixedEndTime
);
}
function getPMul()
public
view
returns(uint256)
{
return Helper.getEarlyIncomeMul(curRTicketSum);
}
function getPTicketSumByRound(uint256 _rId, address _buyer)
public
view
returns(uint256)
{
return round[_rId].pTicketSum[_buyer];
}
function getTicketSumToRound(uint256 _rId)
public
view
returns(uint256)
{
return round[_rId].ticketSum;
}
function getPInvestedSumByRound(uint256 _rId, address _buyer)
public
view
returns(uint256)
{
return round[_rId].pInvestedSum[_buyer];
}
function getInvestedSumToRound(uint256 _rId)
public
view
returns(uint256)
{
return round[_rId].investedSum;
}
function getPSlotLength(address _sender)
public
view
returns(uint256)
{
return pSlot[_sender].length;
}
function getSlotLength()
public
view
returns(uint256)
{
return slot.length;
}
function getSlotId(address _sender, uint256 i)
public
view
returns(uint256)
{
return pSlot[_sender][i];
}
function getSlotInfo(uint256 _slotId)
public
view
returns(address, uint256[4], string)
{
Slot memory _slot = slot[_slotId];
return (_slot.buyer,[_slot.rId, _slot.tNumberFrom, _slot.tNumberTo, _slot.ethAmount], Helper.uintToString(_slot.salt));
}
function cashoutable(address _address)
public
view
returns(bool)
{
// need 1 ticket of curRound or lastRound in waiting time to start new round
if (round[curRoundId].pTicketSum[_address] >= CASHOUT_REQ) return true;
if (round[curRoundId].startTime > block.timestamp) {
// underflow return false
uint256 _lastRoundTickets = getPTicketSumByRound(curRoundId - 1, _address);
if (_lastRoundTickets >= CASHOUT_REQ) return true;
}
return false;
}
// set endRound, prepare to upgrade new version
function setLastRound(uint256 _lastRoundId)
public
onlyDevTeam()
{
require(_lastRoundId >= 8 && _lastRoundId > curRoundId, "too early to end");
require(lastRoundId == 88888888, "already set");
lastRoundId = _lastRoundId;
}
function sBountyClaim(address _sBountyHunter)
public
notStarted()
returns(uint256)
{
require(msg.sender == address(rewardContract), "only Reward contract can manage sBountys");
uint256 _lastRoundTickets = round[curRoundId - 1].pBoughtTicketSum[_sBountyHunter];
uint256 _sBountyTickets = _lastRoundTickets * sBountyPercent / 100;
mintSlot(_sBountyHunter, _sBountyTickets, 0, 0);
return _sBountyTickets;
}
/*
TEST
*/
// function forceEndRound()
// public
// {
// round[curRoundId].keyBlockNr = block.number;
// round[curRoundId].slideEndTime = block.timestamp;
// round[curRoundId].fixedEndTime = block.timestamp;
// }
// function setTimer1(uint256 _hours)
// public
// {
// round[curRoundId].slideEndTime = block.timestamp + _hours * 1 hours + 60;
// round[curRoundId].keyBlockNr = genEstKeyBlockNr(round[curRoundId].slideEndTime);
// }
// function setTimer2(uint256 _days)
// public
// {
// round[curRoundId].fixedEndTime = block.timestamp + _days * 1 days + 60;
// require(round[curRoundId].fixedEndTime >= round[curRoundId].slideEndTime, "invalid test data");
// }
}
interface F2mInterface {
function joinNetwork(address[6] _contract) public;
// one time called
// function disableRound0() public;
function activeBuy() public;
// function premine() public;
// Dividends from all sources (DApps, Donate ...)
function pushDividends() public payable;
/**
* Converts all of caller's dividends to tokens.
*/
function buyFor(address _buyer) public payable;
function sell(uint256 _tokenAmount) public;
function exit() public;
function devTeamWithdraw() public returns(uint256);
function withdrawFor(address sender) public returns(uint256);
function transfer(address _to, uint256 _tokenAmount) public returns(bool);
/*---------- ADMINISTRATOR ONLY FUNCTIONS ----------*/
function setAutoBuy() public;
/*==========================================
= PUBLIC FUNCTIONS =
==========================================*/
function ethBalance(address _address) public view returns(uint256);
function myBalance() public view returns(uint256);
function myEthBalance() public view returns(uint256);
function swapToken() public;
function setNewToken(address _newTokenAddress) public;
}
interface CitizenInterface {
function joinNetwork(address[6] _contract) public;
/*---------- ADMINISTRATOR ONLY FUNCTIONS ----------*/
function devTeamWithdraw() public;
/*---------- WRITE FUNCTIONS ----------*/
function updateUsername(string _sNewUsername) public;
//Sources: Token contract, DApps
function pushRefIncome(address _sender) public payable;
function withdrawFor(address _sender) public payable returns(uint256);
function devTeamReinvest() public returns(uint256);
/*---------- READ FUNCTIONS ----------*/
function getRefWallet(address _address) public view returns(uint256);
}
interface DevTeamInterface {
function setF2mAddress(address _address) public;
function setLotteryAddress(address _address) public;
function setCitizenAddress(address _address) public;
function setBankAddress(address _address) public;
function setRewardAddress(address _address) public;
function setWhitelistAddress(address _address) public;
function setupNetwork() public;
}
interface BankInterface {
function joinNetwork(address[6] _contract) public;
function pushToBank(address _player) public payable;
}
interface RewardInterface {
function mintReward(
address _lucker,
uint256 curRoundId,
uint256 _winNr,
uint256 _tNumberFrom,
uint256 _tNumberTo,
uint256 _value,
uint256 _rewardType)
public;
function joinNetwork(address[6] _contract) public;
function pushBounty(uint256 _curRoundId) public payable;
function resetCounter(uint256 _curRoundId) public;
}
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
int256 constant private INT256_MIN = -2**255;
/**
* @dev Multiplies two unsigned integers, reverts on 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-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Multiplies two signed integers, reverts on overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
// 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-solidity/pull/522
if (a == 0) {
return 0;
}
require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below
int256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Integer division of two signed integers truncating the quotient, reverts on division by zero.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0); // Solidity only automatically asserts when dividing by 0
require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
int256 c = a / b;
return c;
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Subtracts two signed integers, reverts on overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
/**
* @dev Adds two signed integers, reverts on overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
} | dummy slot between every 2 rounds dummy slot never win jackpot cause of min 0.1 ETH _slot.tNumberTo = round[curRoundId].ticketSum; started with 3 hours timeout | function checkpoint()
private
{
Slot memory _slot;
slot.push(_slot);
Round memory _round;
_round.startTime = NEWROUND_WAIT_DURATION.add(block.timestamp);
_round.slideEndTime = TIMEOUT0 + _round.startTime;
_round.fixedEndTime = TIMEOUT2 + _round.startTime;
_round.keyBlockNr = genEstKeyBlockNr(_round.slideEndTime);
_round.ticketSum = round[curRoundId].ticketSum;
_round.investedSum = round[curRoundId].investedSum;
_round.slotSum = slot.length;
curRoundId = curRoundId + 1;
round[curRoundId] = _round;
initGrandPot = grandPot;
curRTicketSum = 0;
}
| 887,418 | [
1,
21050,
4694,
3086,
3614,
576,
21196,
9609,
4694,
5903,
5657,
525,
484,
13130,
4620,
434,
1131,
374,
18,
21,
512,
2455,
389,
14194,
18,
88,
1854,
774,
273,
3643,
63,
1397,
11066,
548,
8009,
16282,
3495,
31,
5746,
598,
890,
7507,
2021,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
9776,
1435,
7010,
3639,
3238,
203,
565,
288,
203,
3639,
23195,
3778,
389,
14194,
31,
203,
3639,
4694,
18,
6206,
24899,
14194,
1769,
203,
203,
3639,
11370,
3778,
389,
2260,
31,
203,
3639,
389,
2260,
18,
1937,
950,
273,
12887,
15092,
67,
19046,
67,
24951,
18,
1289,
12,
2629,
18,
5508,
1769,
203,
3639,
389,
2260,
18,
26371,
25255,
273,
24374,
20,
397,
389,
2260,
18,
1937,
950,
31,
203,
3639,
389,
2260,
18,
12429,
25255,
273,
24374,
22,
397,
389,
2260,
18,
1937,
950,
31,
203,
3639,
389,
2260,
18,
856,
1768,
18726,
273,
3157,
9122,
653,
1768,
18726,
24899,
2260,
18,
26371,
25255,
1769,
203,
3639,
389,
2260,
18,
16282,
3495,
273,
3643,
63,
1397,
11066,
548,
8009,
16282,
3495,
31,
203,
3639,
389,
2260,
18,
5768,
3149,
3495,
273,
3643,
63,
1397,
11066,
548,
8009,
5768,
3149,
3495,
31,
203,
3639,
389,
2260,
18,
14194,
3495,
273,
4694,
18,
2469,
31,
203,
203,
3639,
662,
11066,
548,
273,
662,
11066,
548,
397,
404,
31,
203,
3639,
3643,
63,
1397,
11066,
548,
65,
273,
389,
2260,
31,
203,
203,
3639,
1208,
43,
7884,
18411,
273,
16225,
18411,
31,
203,
3639,
662,
54,
13614,
3495,
273,
374,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
//Address: 0xa1f58f081c67dfd9ef93955c06877cbf357b5c56
//Contract name: DogRace
//Balance: 0 Ether
//Verification Date: 4/17/2018
//Transacion Count: 10
// CODE STARTS HERE
pragma solidity ^0.4.19;
// File: contracts/SafeMath.sol
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: contracts/oraclizeLib.sol
// <ORACLIZE_API_LIB>
/*
Copyright (c) 2015-2016 Oraclize SRL
Copyright (c) 2016 Oraclize LTD
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
pragma solidity ^0.4.0;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) payable returns (bytes32 _id);
function getPrice(string _datasource) returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
library oraclizeLib {
//byte constant internal proofType_NONE = 0x00;
function proofType_NONE()
constant
returns (byte) {
return 0x00;
}
//byte constant internal proofType_TLSNotary = 0x10;
function proofType_TLSNotary()
constant
returns (byte) {
return 0x10;
}
//byte constant internal proofStorage_IPFS = 0x01;
function proofStorage_IPFS()
constant
returns (byte) {
return 0x01;
}
// *******TRUFFLE + BRIDGE*********
//OraclizeAddrResolverI constant public OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
// *****REALNET DEPLOYMENT******
OraclizeAddrResolverI constant public OAR = oraclize_setNetwork(); // constant means dont store and re-eval on each call
function getOAR()
constant
returns (OraclizeAddrResolverI) {
return OAR;
}
OraclizeI constant public oraclize = OraclizeI(OAR.getAddress());
function getCON()
constant
returns (OraclizeI) {
return oraclize;
}
function oraclize_setNetwork()
public
returns(OraclizeAddrResolverI){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ //mainnet
return OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
}
if (getCodeSize(0xb9b00A7aE2e1D3557d7Ec7e0633e25739A6B510e)>0) { // ropsten custom ethereum bridge
return OraclizeAddrResolverI(0xb9b00A7aE2e1D3557d7Ec7e0633e25739A6B510e);
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){ //ropsten testnet
return OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){ //kovan testnet
return OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){ //rinkeby testnet
return OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){ //ethereum-bridge
return OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){ //ether.camp ide
return OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){ //browser-solidity
return OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
}
}
function oraclize_getPrice(string datasource)
public
returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit)
public
returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg)
public
returns (bytes32 id){
return oraclize_query(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg)
public
returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(string datasource, string arg, uint gaslimit)
public
returns (bytes32 id){
return oraclize_query(0, datasource, arg, gaslimit);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit)
public
returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2)
public
returns (bytes32 id){
return oraclize_query(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2)
public
returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit)
public
returns (bytes32 id){
return oraclize_query(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit)
public
returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN)
internal
returns (bytes32 id){
return oraclize_query(0, datasource, argN);
}
function oraclize_query(uint timestamp, string datasource, string[] argN)
internal
returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit)
internal
returns (bytes32 id){
return oraclize_query(0, datasource, argN, gaslimit);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit)
internal
returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_cbAddress()
public
constant
returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP)
public {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice)
public {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_setConfig(bytes32 config)
public {
return oraclize.setConfig(config);
}
function getCodeSize(address _addr)
public
returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a)
public
returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b)
public
returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle)
public
returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e)
internal
returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d)
internal
returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c)
internal
returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b)
internal
returns (string) {
return strConcat(_a, _b, "", "", "");
}
// parseInt
function parseInt(string _a)
public
constant
returns (uint) {
return parseInt(_a, 0);
}
// parseInt(parseFloat*10^_b)
function parseInt(string _a, uint _b)
public
constant
returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i)
internal
returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
function stra2cbor(string[] arr)
internal
returns (bytes) {
uint arrlen = arr.length;
// get correct cbor output length
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; //+3 accounts for paired identifier types
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
// if there's a bug with larger strings, this may be the culprit
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
function b2s(bytes _b)
internal
returns (string) {
bytes memory output = new bytes(_b.length * 2);
uint len = output.length;
assembly {
let i := 0
let mem := 0
loop:
// isolate octet
0x1000000000000000000000000000000000000000000000000000000000000000
exp(0x10, mod(i, 0x40))
// change offset only if needed
jumpi(skip, gt(mod(i, 0x40), 0))
// save offset mem for reuse
mem := mload(add(_b, add(mul(0x20, div(i, 0x40)), 0x20)))
skip:
mem
mul
div
dup1
// check if alpha or numerical, jump if numerical
0x0a
swap1
lt
num
jumpi
// offset alpha char correctly
0x0a
swap1
sub
alp:
0x61
add
jump(end)
num:
0x30
add
end:
add(output, add(0x20, i))
mstore8
i := add(i, 1)
jumpi(loop, gt(len, i))
}
return string(output);
}
}
// </ORACLIZE_API_LIB>
// File: contracts/DogRace.sol
//contract DogRace is usingOraclize {
contract DogRace {
using SafeMath for uint256;
string public constant version = "0.0.5";
uint public constant min_bet = 0.1 ether;
uint public constant max_bet = 1 ether;
uint public constant house_fee_pct = 5;
uint public constant claim_period = 30 days;
address public owner; // owner address
// Currencies: BTC, ETH, LTC, BCH, XRP
uint8 constant dogs_count = 5;
// Race states and timing
struct chronus_struct {
bool betting_open; // boolean: check if betting is open
bool race_start; // boolean: check if race has started
bool race_end; // boolean: check if race has ended
bool race_voided; // boolean: check if race has been voided
uint starting_time; // timestamp of when the race starts
uint betting_duration; // duration of betting period
uint race_duration; // duration of the race
}
// Single bet information
struct bet_info {
uint8 dog; // Dog on which the bet is made
uint amount; // Amount of the bet
}
// Dog pool information
struct pool_info {
uint bets_total; // total bets amount
uint pre; // start price
uint post; // ending price
int delta; // price delta
bool post_check; // differentiating pre and post prices in oraclize callback
bool winner; // has respective dog won the race?
}
// Bettor information
struct bettor_info {
uint bets_total; // total bets amount
bool rewarded; // if reward was paid to the bettor
bet_info[] bets; // array of bets
}
mapping (bytes32 => uint) oraclize_query_ids; // mapping oraclize query IDs => dogs
mapping (address => bettor_info) bettors; // mapping bettor address => bettor information
pool_info[dogs_count] pools; // pools for each currency
chronus_struct chronus; // states and timing
uint public bets_total = 0; // total amount of bets
uint public reward_total = 0; // total amount to be distributed among winners
uint public winning_bets_total = 0; // total amount of bets in winning pool(s)
uint prices_remaining = dogs_count; // variable to check if all prices are received at the end of the race
int max_delta = int256((uint256(1) << 255)); // winner dog(s) delta; initialize to minimal int value
// tracking events
event OraclizeQuery(string description);
event PriceTicker(uint dog, uint price);
event Bet(address from, uint256 _value, uint dog);
event Reward(address to, uint256 _value);
event HouseFee(uint256 _value);
// constructor
function DogRace() public {
owner = msg.sender;
oraclizeLib.oraclize_setCustomGasPrice(20000000000 wei); // 20GWei
}
// modifiers for restricting access to methods
modifier onlyOwner {
require(owner == msg.sender);
_;
}
modifier duringBetting {
require(chronus.betting_open);
_;
}
modifier beforeBetting {
require(!chronus.betting_open && !chronus.race_start);
_;
}
modifier afterRace {
require(chronus.race_end);
_;
}
// ======== Bettor interface ===============================================================================================
// place a bet
function place_bet(uint8 dog) external duringBetting payable {
require(msg.value >= min_bet && msg.value <= max_bet && dog < dogs_count);
bet_info memory current_bet;
// Update bettors info
current_bet.amount = msg.value;
current_bet.dog = dog;
bettors[msg.sender].bets.push(current_bet);
bettors[msg.sender].bets_total = bettors[msg.sender].bets_total.add(msg.value);
// Update pools info
pools[dog].bets_total = pools[dog].bets_total.add(msg.value);
bets_total = bets_total.add(msg.value);
Bet(msg.sender, msg.value, dog);
}
// fallback method for accepting payments
function () private payable {}
// method to check the reward amount
function check_reward() afterRace external constant returns (uint) {
return bettor_reward(msg.sender);
}
// method to claim the reward
function claim_reward() afterRace external {
require(!bettors[msg.sender].rewarded);
uint reward = bettor_reward(msg.sender);
require(reward > 0 && this.balance >= reward);
bettors[msg.sender].rewarded = true;
msg.sender.transfer(reward);
Reward(msg.sender, reward);
}
// ============================================================================================================================
//oraclize callback method
function __callback(bytes32 myid, string result) public {
require (msg.sender == oraclizeLib.oraclize_cbAddress());
chronus.race_start = true;
chronus.betting_open = false;
uint dog_index = oraclize_query_ids[myid];
require(dog_index > 0); // Check if the query id is known
dog_index--;
oraclize_query_ids[myid] = 0; // Prevent duplicate callbacks
if (!pools[dog_index].post_check) {
pools[dog_index].pre = oraclizeLib.parseInt(result, 3); // from Oraclize
pools[dog_index].post_check = true; // next check for the coin will be ending price check
PriceTicker(dog_index, pools[dog_index].pre);
} else {
pools[dog_index].post = oraclizeLib.parseInt(result, 3); // from Oraclize
// calculating the difference in price with a precision of 5 digits
pools[dog_index].delta = int(pools[dog_index].post - pools[dog_index].pre) * 10000 / int(pools[dog_index].pre);
if (max_delta < pools[dog_index].delta) {
max_delta = pools[dog_index].delta;
}
PriceTicker(dog_index, pools[dog_index].post);
prices_remaining--; // How many end prices are to be received
if (prices_remaining == 0) { // If all end prices have been received, then process rewards
end_race();
}
}
}
// calculate bettor's reward
function bettor_reward(address candidate) internal afterRace constant returns(uint reward) {
bettor_info storage bettor = bettors[candidate];
if (chronus.race_voided) {
reward = bettor.bets_total;
} else {
if (reward_total == 0) {
return 0;
}
uint winning_bets = 0;
for (uint i = 0; i < bettor.bets.length; i++) {
if (pools[bettor.bets[i].dog].winner) {
winning_bets = winning_bets.add(bettor.bets[i].amount);
}
}
reward = reward_total.mul(winning_bets).div(winning_bets_total);
}
}
// ============= DApp interface ==============================================================================================
// exposing pool details for DApp
function get_pool(uint dog) external constant returns (uint, uint, uint, int, bool, bool) {
return (pools[dog].bets_total, pools[dog].pre, pools[dog].post, pools[dog].delta, pools[dog].post_check, pools[dog].winner);
}
// exposing chronus for DApp
function get_chronus() external constant returns (bool, bool, bool, bool, uint, uint, uint) {
return (chronus.betting_open, chronus.race_start, chronus.race_end, chronus.race_voided, chronus.starting_time, chronus.betting_duration, chronus.race_duration);
}
// exposing bettor info for DApp
function get_bettor_nfo() external constant returns (uint, uint, bool) {
bettor_info info = bettors[msg.sender];
return (info.bets_total, info.bets.length, info.rewarded);
}
// exposing bets info for DApp
function get_bet_nfo(uint bet_num) external constant returns (uint, uint) {
bettor_info info = bettors[msg.sender];
bet_info b_info = info.bets[bet_num];
return (b_info.dog, b_info.amount);
}
// =========== race lifecycle management functions ================================================================================
// place the oraclize queries and open betting
function setup_race(uint betting_period, uint racing_period) public onlyOwner beforeBetting payable returns(bool) {
// We have to send 2 queries for each dog; check if we have enough ether for this
require (oraclizeLib.oraclize_getPrice("URL", 500000) * 2 * dogs_count < this.balance);
chronus.starting_time = block.timestamp;
chronus.betting_open = true;
uint delay = betting_period.add(60); //slack time 1 minute
chronus.betting_duration = delay;
oraclize_query_ids[oraclizeLib.oraclize_query(delay, "URL", "json(https://api.coinmarketcap.com/v1/ticker/bitcoin/).0.price_usd", 500000)] = 1;
oraclize_query_ids[oraclizeLib.oraclize_query(delay, "URL", "json(https://api.coinmarketcap.com/v1/ticker/ethereum/).0.price_usd", 500000)] = 2;
oraclize_query_ids[oraclizeLib.oraclize_query(delay, "URL", "json(https://api.coinmarketcap.com/v1/ticker/litecoin/).0.price_usd", 500000)] = 3;
oraclize_query_ids[oraclizeLib.oraclize_query(delay, "URL", "json(https://api.coinmarketcap.com/v1/ticker/bitcoin-cash/).0.price_usd", 500000)] = 4;
oraclize_query_ids[oraclizeLib.oraclize_query(delay, "URL", "json(https://api.coinmarketcap.com/v1/ticker/ripple/).0.price_usd", 500000)] = 5;
delay = delay.add(racing_period);
oraclize_query_ids[oraclizeLib.oraclize_query(delay, "URL", "json(https://api.coinmarketcap.com/v1/ticker/bitcoin/).0.price_usd", 500000)] = 1;
oraclize_query_ids[oraclizeLib.oraclize_query(delay, "URL", "json(https://api.coinmarketcap.com/v1/ticker/ethereum/).0.price_usd", 500000)] = 2;
oraclize_query_ids[oraclizeLib.oraclize_query(delay, "URL", "json(https://api.coinmarketcap.com/v1/ticker/litecoin/).0.price_usd", 500000)] = 3;
oraclize_query_ids[oraclizeLib.oraclize_query(delay, "URL", "json(https://api.coinmarketcap.com/v1/ticker/bitcoin-cash/).0.price_usd", 500000)] = 4;
oraclize_query_ids[oraclizeLib.oraclize_query(delay, "URL", "json(https://api.coinmarketcap.com/v1/ticker/ripple/).0.price_usd", 500000)] = 5;
OraclizeQuery("Oraclize queries were sent");
chronus.race_duration = delay;
return true;
}
// end race and transfer house fee (called internally by callback)
function end_race() internal {
chronus.race_end = true;
// calculate winning pool(s) and their total amount
for (uint dog = 0; dog < dogs_count; dog++) {
if (pools[dog].delta == max_delta) {
pools[dog].winner = true;
winning_bets_total = winning_bets_total.add(pools[dog].bets_total);
}
}
// calculate house fee and transfer it to contract owner
uint house_fee;
if (winning_bets_total == 0) { // No winners => house takes all the money
reward_total = 0;
house_fee = this.balance;
} else {
if (winning_bets_total == bets_total) { // All the bettors are winners => void the race => no house fee; everyone gets their bets back
chronus.race_voided = true;
house_fee = 0;
} else {
house_fee = bets_total.mul(house_fee_pct).div(100); // calculate house fee as % of total bets
}
reward_total = bets_total.sub(house_fee); // subtract house_fee from total reward
house_fee = this.balance.sub(reward_total); // this.balance will also include remains of kickcstart ether
}
HouseFee(house_fee);
owner.transfer(house_fee);
}
// in case of any errors in race, enable full refund for the bettors to claim
function void_race() external onlyOwner {
require(now > chronus.starting_time + chronus.race_duration);
require((chronus.betting_open && !chronus.race_start)
|| (chronus.race_start && !chronus.race_end));
chronus.betting_open = false;
chronus.race_voided = true;
chronus.race_end = true;
}
// method to retrieve unclaimed winnings after claim period has ended
function recover_unclaimed_bets() external onlyOwner {
require(now > chronus.starting_time + chronus.race_duration + claim_period);
require(chronus.race_end);
owner.transfer(this.balance);
}
// selfdestruct (returns balance to the owner)
function kill() external onlyOwner {
selfdestruct(msg.sender);
}
}
| duration of betting period
| uint betting_duration; | 15,811,025 | [
1,
8760,
434,
2701,
1787,
3879,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
2254,
225,
2701,
1787,
67,
8760,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity ^0.4.15;
import 'zeppelin-solidity/contracts/math/SafeMath.sol';
import './TokenLifecycle.sol';
import './PurchasableToken.sol';
import './BurnableToken.sol';
import './FinalizableToken.sol';
import './RefundVault.sol';
/**
* @title A Refundable Token
* @author Tavit Ohanian
* @dev Adapted from the OpenZeppelin library (RefundableCrowdsale).
* @dev Extension of FinalizableToken that adds a funding goal, and
* @dev the possibility of users getting a refund if goal is not met.
* @dev Uses a RefundVault as a token sale vault.
*/
contract RefundableToken is PurchasableToken, RefundVault {
using SafeMath for uint256;
/**
* @dev State definitions
*/
/**
* @notice minimum amount of funds to be raised in weis
* @notice from token purchases
*/
uint256 public goal;
/**
* @dev Event definitions
*/
/**
* @dev Constructor
*/
/**
* @notice RefundableToken(address _previousToken, address _tokenManager,
* address _escrow, uint256 _rate, uint256 _goal)
* @param _previousToken Presale token contract address.
* @param _tokenManager Token manager address.
* @param _escrow MultiSig account address that will withdraw Ether from token purchases.
* @param _rate base purchase rate.
* @param _goal fundraiser minimum goal
*/
function RefundableToken(address _previousToken, address _tokenManager,
address _escrow, uint256 _rate, uint256 _goal) public
BasicToken(_tokenManager)
PurchasableToken(_previousToken, _escrow, _rate)
RefundVault(_escrow)
BurnableToken()
StandardToken()
MintableToken()
FinalizableToken()
{
require(_goal > 0);
// goal in wei = (_goal in ether) * (1 ether / 1 wei)
goal = _goal * (1 ether / 1 wei);
}
/**
* @dev Fallback function (if exists)
*/
/**
* @dev External functions
*/
/**
* @dev Public functions
*/
/**
* @notice Function to forward funds from token purchase
* @notice overrides default token implementation to use refund vault
*/
function forwardFunds() internal {
//deposit(msg.sender);
this.deposit.value(msg.value)(msg.sender);
}
/**
* @dev if crowdsale is unsuccessful, investors can claim refunds here
*/
function claimRefund() public {
require(isFinalized);
require(!goalReached());
refund(msg.sender);
}
/**
* @dev checks if crowdsale is successful
*/
function goalReached() public constant returns (bool) {
return weiRaised >= goal;
}
/**
* @dev Internal functions
*/
/**
* @dev vault finalization task, called when owner calls finalize()
*/
function finalization() internal {
if (goalReached()) {
close();
// mint additional tokens for defined allocation pools
mintDefinedPools();
currentPhase = Phase.Finalized; // token is finalized
} else {
enableRefunds();
currentPhase = Phase.Refunding; // token is refunding
}
super.finalization(); // declare minting has finished
}
/**
* @dev Private functions
*/
/**
* @dev goal is reached:
* @dev - on successful sale, additional pools of token are minted and initially
* @dev allocated to token manager:
* @dev 1) Management and Advisors Pool ==> 10% of totalSupply
* @dev 2) Founders and Project Team ==> 25% of totalSupply
* @dev 3) Bounty and other Pool ==> 10% of totalSupply
* @dev - 4,500,000 VMT issued to the contributors of earlier developed Vectavi assets
* @dev - remaining VMT is reserved for bounty (exchanged for ether to fund bounty
* @dev contracts). bounty is separate contract funded with ether by token manager
*/
function mintDefinedPools() private {
require(tokenManager != 0x0);
//
// sale (current totalSupply) represents 55% of final token supply
// need to mint additional poolSupply tokens representing 45% of
// final token totalSupply: poolSupply = totalSupply * (45 / 55)
// the minted poolSupply is initially allocated to the token manager
//
uint256 poolSupply = SafeMath.div(SafeMath.mul(totalSupply, 45),55);
// grant/revoke of vested tokens must be from same msg.sender
mint(wallet, poolSupply);
}
}
| * @dev State definitions/* @notice minimum amount of funds to be raised in weis @notice from token purchases/* @dev Event definitions/* @dev Constructor/* @notice RefundableToken(address _previousToken, address _tokenManager, address _escrow, uint256 _rate, uint256 _goal) @param _previousToken Presale token contract address. @param _tokenManager Token manager address. @param _escrow MultiSig account address that will withdraw Ether from token purchases. @param _rate base purchase rate. @param _goal fundraiser minimum goal/ goal in wei = (_goal in ether) * (1 ether / 1 wei) | {
require(_goal > 0);
goal = _goal * (1 ether / 1 wei);
}
| 2,507,404 | [
1,
1119,
6377,
19,
225,
5224,
3844,
434,
284,
19156,
358,
506,
11531,
316,
732,
291,
225,
628,
1147,
5405,
343,
3304,
19,
225,
2587,
6377,
19,
225,
11417,
19,
225,
3941,
1074,
429,
1345,
12,
2867,
389,
11515,
1345,
16,
1758,
389,
2316,
1318,
16,
18701,
1758,
389,
742,
492,
16,
2254,
5034,
389,
5141,
16,
2254,
5034,
389,
27354,
13,
225,
389,
11515,
1345,
18346,
5349,
1147,
6835,
1758,
18,
225,
389,
2316,
1318,
3155,
3301,
1758,
18,
225,
389,
742,
492,
5991,
8267,
2236,
1758,
716,
903,
598,
9446,
512,
1136,
628,
1147,
5405,
343,
3304,
18,
225,
389,
5141,
1026,
23701,
4993,
18,
225,
389,
27354,
284,
1074,
354,
15914,
5224,
17683,
19,
17683,
316,
732,
77,
273,
261,
67,
27354,
316,
225,
2437,
13,
225,
261,
21,
225,
2437,
342,
404,
732,
77,
13,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
288,
203,
3639,
2583,
24899,
27354,
405,
374,
1769,
203,
3639,
17683,
273,
389,
27354,
380,
261,
21,
225,
2437,
342,
404,
732,
77,
1769,
7010,
565,
289,
203,
203,
203,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
/**
*Submitted for verification at Etherscan.io on 2020-09-25
*/
// File: openzeppelin-solidity/contracts/GSN/Context.sol
// 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;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
// SPDX-License-Identifier: MIT
/**
* @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);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
// SPDX-License-Identifier: MIT
/**
* @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;
}
}
// File: openzeppelin-solidity/contracts/utils/Address.sol
// SPDX-License-Identifier: MIT
/**
* @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) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
/**
* @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);
}
}
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
// SPDX-License-Identifier: MIT
/**
* @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 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 { }
}
/**
* @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;
}
}
// mock class using ERC20
contract ERC20SAP is ERC20, Ownable {
constructor (
string memory name,
string memory symbol,
address initialAccount,
uint256 initialBalance
) public payable ERC20(name, symbol) {
_mint(initialAccount, initialBalance);
}
function mint(address account, uint256 amount) public {
_mint(account, amount);
}
function burn(address account, uint256 amount) public {
_burn(account, amount);
}
function transferInternal(address from, address to, uint256 value) public {
_transfer(from, to, value);
}
function approveInternal(address owner, address spender, uint256 value) public {
_approve(owner, spender, value);
}
} | mock class using ERC20 | contract ERC20SAP is ERC20, Ownable {
constructor (
string memory name,
string memory symbol,
address initialAccount,
uint256 initialBalance
) public payable ERC20(name, symbol) {
_mint(initialAccount, initialBalance);
}
function mint(address account, uint256 amount) public {
_mint(account, amount);
}
function burn(address account, uint256 amount) public {
_burn(account, amount);
}
function transferInternal(address from, address to, uint256 value) public {
_transfer(from, to, value);
}
function approveInternal(address owner, address spender, uint256 value) public {
_approve(owner, spender, value);
}
} | 5,886,351 | [
1,
22851,
667,
1450,
4232,
39,
3462,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
4232,
39,
3462,
55,
2203,
353,
4232,
39,
3462,
16,
14223,
6914,
288,
203,
565,
3885,
261,
203,
3639,
533,
3778,
508,
16,
203,
3639,
533,
3778,
3273,
16,
203,
3639,
1758,
2172,
3032,
16,
203,
3639,
2254,
5034,
2172,
13937,
203,
565,
262,
1071,
8843,
429,
4232,
39,
3462,
12,
529,
16,
3273,
13,
288,
203,
3639,
389,
81,
474,
12,
6769,
3032,
16,
2172,
13937,
1769,
203,
565,
289,
203,
203,
565,
445,
312,
474,
12,
2867,
2236,
16,
2254,
5034,
3844,
13,
1071,
288,
203,
3639,
389,
81,
474,
12,
4631,
16,
3844,
1769,
203,
565,
289,
203,
203,
565,
445,
18305,
12,
2867,
2236,
16,
2254,
5034,
3844,
13,
1071,
288,
203,
3639,
389,
70,
321,
12,
4631,
16,
3844,
1769,
203,
565,
289,
203,
203,
565,
445,
7412,
3061,
12,
2867,
628,
16,
1758,
358,
16,
2254,
5034,
460,
13,
1071,
288,
203,
3639,
389,
13866,
12,
2080,
16,
358,
16,
460,
1769,
203,
565,
289,
203,
203,
565,
445,
6617,
537,
3061,
12,
2867,
3410,
16,
1758,
17571,
264,
16,
2254,
5034,
460,
13,
1071,
288,
203,
3639,
389,
12908,
537,
12,
8443,
16,
17571,
264,
16,
460,
1769,
203,
565,
289,
203,
97,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
/**
* Crypto Bunny Factory
* Buy,sell,trade and mate crypto based digital bunnies
*
* Developer Team
* Check on CryptoBunnies.com
*
**/
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// The ERC-721 Interface to reference the animal factory token
interface ERC721Interface {
function totalSupply() public view returns (uint256);
function safeTransferFrom(address _from, address _to, uint256 _tokenId);
function burnToken(address tokenOwner, uint256 tid) ;
function sendToken(address sendTo, uint tid, string tmeta) ;
function getTotalTokensAgainstAddress(address ownerAddress) public constant returns (uint totalAnimals);
function getAnimalIdAgainstAddress(address ownerAddress) public constant returns (uint[] listAnimals);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function setAnimalMeta(uint tid, string tmeta);
}
contract AnimalFactory is Ownable
{
//The structure defining a single animal
struct AnimalProperties
{
uint id;
string name;
string desc;
bool upForSale;
uint priceForSale;
bool upForMating;
bool eggPhase;
uint priceForMating;
bool isBornByMating;
uint parentId1;
uint parentId2;
uint birthdate;
uint costumeId;
uint generationId;
bool isSpecial;
}
using SafeMath for uint256;
// The token being sold
ERC721Interface public token;
//sequentially generated ids for the animals
uint uniqueAnimalId=0;
//mapping to show all the animal properties against a single id
mapping(uint=>AnimalProperties) animalAgainstId;
//mapping to show how many children does a single animal has
mapping(uint=>uint[]) childrenIdAgainstAnimalId;
//the animals that have been advertised for mating
uint[] upForMatingList;
//the animals that have been advertised for selling
uint[] upForSaleList;
//the list of addresses that can remove animals from egg phase
address[] memberAddresses;
//animal object to be used in various functions as an intermediate variable
AnimalProperties animalObject;
//The owner percentages from mating and selling transactions
uint public ownerPerThousandShareForMating = 35;
uint public ownerPerThousandShareForBuying = 35;
//the number of free animals an address can claim
uint public freeAnimalsLimit = 4;
//variable to show whether the contract has been paused or not
bool public isContractPaused;
//the fees for advertising an animal for sale and mate
uint public priceForMateAdvertisement;
uint public priceForSaleAdvertisement;
uint public priceForBuyingCostume;
// amount of raised money in wei
uint256 public weiRaised;
// Total no of bunnies created
uint256 public totalBunniesCreated=0;
//rate of each animal
uint256 public weiPerAnimal = 1*10**18;
uint[] eggPhaseAnimalIds;
uint[] animalIdsWithPendingCostumes;
/**
* event for animals purchase logging
* @param purchaser who paid for the animals
* @param beneficiary who got the animals
* @param value weis paid for purchase
* @param amount of animals purchased
*/
event AnimalsPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function AnimalFactory(address _walletOwner,address _tokenAddress) public
{
require(_walletOwner != 0x0);
owner = _walletOwner;
isContractPaused = false;
priceForMateAdvertisement = 1 * 10 ** 16;
priceForSaleAdvertisement = 1 * 10 ** 16;
priceForBuyingCostume = 1 * 10 ** 16;
token = ERC721Interface(_tokenAddress);
}
/**
* function to get animal details by id
**/
function getAnimalById(uint aid) public constant returns
(string, string,uint,uint ,uint, uint,uint)
{
if(animalAgainstId[aid].eggPhase==true)
{
return(animalAgainstId[aid].name,
animalAgainstId[aid].desc,
2**256 - 1,
animalAgainstId[aid].priceForSale,
animalAgainstId[aid].priceForMating,
animalAgainstId[aid].parentId1,
animalAgainstId[aid].parentId2
);
}
else
{
return(animalAgainstId[aid].name,
animalAgainstId[aid].desc,
animalAgainstId[aid].id,
animalAgainstId[aid].priceForSale,
animalAgainstId[aid].priceForMating,
animalAgainstId[aid].parentId1,
animalAgainstId[aid].parentId2
);
}
}
function getAnimalByIdVisibility(uint aid) public constant
returns (bool upforsale,bool upformating,bool eggphase,bool isbornbymating,
uint birthdate, uint costumeid, uint generationid)
{
return(
animalAgainstId[aid].upForSale,
animalAgainstId[aid].upForMating,
animalAgainstId[aid].eggPhase,
animalAgainstId[aid].isBornByMating,
animalAgainstId[aid].birthdate,
animalAgainstId[aid].costumeId,
animalAgainstId[aid].generationId
);
}
function getOwnerByAnimalId(uint aid) public constant
returns (address)
{
return token.ownerOf(aid);
}
/**
* function to get all animals against an address
**/
function getAllAnimalsByAddress(address ad) public constant returns (uint[] listAnimals)
{
require (!isContractPaused);
return token.getAnimalIdAgainstAddress(ad);
}
/**
* claim an animal from animal factory
**/
function claimFreeAnimalFromAnimalFactory( string animalName, string animalDesc) public
{
require(msg.sender != 0x0);
require (!isContractPaused);
uint gId=0;
//owner can claim as many free animals as he or she wants
if (msg.sender!=owner)
{
require(token.getTotalTokensAgainstAddress(msg.sender)<freeAnimalsLimit);
gId=1;
}
//sequentially generated animal id
uniqueAnimalId++;
//Generating an Animal Record
animalObject = AnimalProperties({
id:uniqueAnimalId,
name:animalName,
desc:animalDesc,
upForSale: false,
eggPhase: false,
priceForSale:0,
upForMating: false,
priceForMating:0,
isBornByMating: false,
parentId1:0,
parentId2:0,
birthdate:now,
costumeId:0,
generationId:gId,
isSpecial:false
});
token.sendToken(msg.sender, uniqueAnimalId,animalName);
//updating the mappings to store animal information
animalAgainstId[uniqueAnimalId]=animalObject;
totalBunniesCreated++;
}
/**
* Function to buy animals from the factory in exchange for ethers
**/
function buyAnimalsFromAnimalFactory(string animalName, string animalDesc) public payable
{
require (!isContractPaused);
require(validPurchase());
require(msg.sender != 0x0);
uint gId=0;
//owner can claim as many free animals as he or she wants
if (msg.sender!=owner)
{
gId=1;
}
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.div(weiPerAnimal);
// update state
weiRaised = weiRaised.add(weiAmount);
uniqueAnimalId++;
//Generating Animal Record
animalObject = AnimalProperties({
id:uniqueAnimalId,
name:animalName,
desc:animalDesc,
upForSale: false,
priceForSale:0,
upForMating: false,
eggPhase: false,
priceForMating:0,
isBornByMating:false,
parentId1:0,
parentId2:0,
birthdate:now,
costumeId:0,
generationId:gId,
isSpecial:false
});
//transferring the token
token.sendToken(msg.sender, uniqueAnimalId,animalName);
emit AnimalsPurchased(msg.sender, owner, weiAmount, tokens);
//updating the mappings to store animal records
animalAgainstId[uniqueAnimalId]=animalObject;
totalBunniesCreated++;
//transferring the ethers to the owner of the contract
owner.transfer(msg.value);
}
/**
* Buying animals from a user
**/
function buyAnimalsFromUser(uint animalId) public payable
{
require (!isContractPaused);
require(msg.sender != 0x0);
address prevOwner=token.ownerOf(animalId);
//checking that a user is not trying to buy an animal from himself
require(prevOwner!=msg.sender);
//the price of sale
uint price=animalAgainstId[animalId].priceForSale;
//the percentage of owner
uint OwnerPercentage=animalAgainstId[animalId].priceForSale.mul(ownerPerThousandShareForBuying);
OwnerPercentage=OwnerPercentage.div(1000);
uint priceWithOwnerPercentage = animalAgainstId[animalId].priceForSale.add(OwnerPercentage);
//funds sent should be enough to cover the selling price plus the owner fees
require(msg.value>=priceWithOwnerPercentage);
// transfer token only
// token.mint(prevOwner,msg.sender,1);
// transfer token here
token.safeTransferFrom(prevOwner,msg.sender,animalId);
// change mapping in animalAgainstId
animalAgainstId[animalId].upForSale=false;
animalAgainstId[animalId].priceForSale=0;
//remove from for sale list
for (uint j=0;j<upForSaleList.length;j++)
{
if (upForSaleList[j] == animalId)
delete upForSaleList[j];
}
//transfer of money from buyer to beneficiary
prevOwner.transfer(price);
//transfer of percentage money to ownerWallet
owner.transfer(OwnerPercentage);
// return extra funds if sent by mistake
if(msg.value>priceWithOwnerPercentage)
{
msg.sender.transfer(msg.value.sub(priceWithOwnerPercentage));
}
}
/**
* function to accept a mate offer by offering one of your own animals
* and paying ethers ofcourse
**/
function mateAnimal(uint parent1Id, uint parent2Id, string animalName,string animalDesc) public payable
{
require (!isContractPaused);
require(msg.sender != 0x0);
//the requester is actually the owner of the animal which he or she is offering for mating
require (token.ownerOf(parent2Id) == msg.sender);
//a user cannot mate two of his own animals
require(token.ownerOf(parent2Id)!=token.ownerOf(parent1Id));
//the animal id given was actually advertised for mating
require(animalAgainstId[parent1Id].upForMating==true);
require(animalAgainstId[parent1Id].isSpecial==false);
require(animalAgainstId[parent2Id].isSpecial==false);
// the price requested for mating
uint price=animalAgainstId[parent1Id].priceForMating;
// the owner fees
uint OwnerPercentage=animalAgainstId[parent1Id].priceForMating.mul(ownerPerThousandShareForMating);
OwnerPercentage=OwnerPercentage.div(1000);
uint priceWithOwnerPercentage = animalAgainstId[parent1Id].priceForMating.add(OwnerPercentage);
// the ethers sent should be enough to cover the mating price and the owner fees
require(msg.value>=priceWithOwnerPercentage);
uint generationnum = 1;
if(animalAgainstId[parent1Id].generationId >= animalAgainstId[parent2Id].generationId)
{
generationnum = animalAgainstId[parent1Id].generationId+1;
}
else{
generationnum = animalAgainstId[parent2Id].generationId+1;
}
// sequentially generated id for animal
uniqueAnimalId++;
//Adding Saving Animal Record
animalObject = AnimalProperties({
id:uniqueAnimalId,
name:animalName,
desc:animalDesc,
upForSale: false,
priceForSale:0,
upForMating: false,
eggPhase: true,
priceForMating:0,
isBornByMating:true,
parentId1: parent1Id,
parentId2: parent2Id,
birthdate:now,
costumeId:0,
generationId:generationnum,
isSpecial:false
});
// transfer token only
token.sendToken(msg.sender,uniqueAnimalId,animalName);
//updating the mappings to store animal information
animalAgainstId[uniqueAnimalId]=animalObject;
//adding the generated animal to egg phase list
eggPhaseAnimalIds.push(uniqueAnimalId);
//adding this animal as a child to the parents who mated to produce this offspring
childrenIdAgainstAnimalId[parent1Id].push(uniqueAnimalId);
childrenIdAgainstAnimalId[parent2Id].push(uniqueAnimalId);
//remove from for mate list
for (uint i=0;i<upForMatingList.length;i++)
{
if (upForMatingList[i]==parent1Id)
delete upForMatingList[i];
}
//remove the parent animal from mating advertisment
animalAgainstId[parent1Id].upForMating = false;
animalAgainstId[parent1Id].priceForMating = 0;
//transfer of money from beneficiary to mate owner
token.ownerOf(parent1Id).transfer(price);
//transfer of percentage money to ownerWallet
owner.transfer(OwnerPercentage);
// return extra funds if sent by mistake
if(msg.value>priceWithOwnerPercentage)
{
msg.sender.transfer(msg.value.sub(priceWithOwnerPercentage));
}
}
/**
* function to transfer an animal to another user
* direct token cannot be passed as we have disabled the transfer feature
* all animal transfers should occur through this function
**/
function TransferAnimalToAnotherUser(uint animalId,address to) public
{
require (!isContractPaused);
require(msg.sender != 0x0);
//the requester of the transfer is actually the owner of the animal id provided
require(token.ownerOf(animalId)==msg.sender);
//if an animal has to be transferred, it shouldnt be up for sale or mate
require(animalAgainstId[animalId].upForSale == false);
require(animalAgainstId[animalId].upForMating == false);
token.safeTransferFrom(msg.sender, to, animalId);
}
/**
* Advertise your animal for selling in exchange for ethers
**/
function putSaleRequest(uint animalId, uint salePrice) public payable
{
require (!isContractPaused);
//everyone except owner has to pay the adertisement fees
if (msg.sender!=owner)
{
require(msg.value>=priceForSaleAdvertisement);
}
//the advertiser is actually the owner of the animal id provided
require(token.ownerOf(animalId)==msg.sender);
//you cannot advertise an animal for sale which is in egg phase
require(animalAgainstId[animalId].eggPhase==false);
// you cannot advertise an animal for sale which is already on sale
require(animalAgainstId[animalId].upForSale==false);
//you cannot put an animal for sale and mate simultaneously
require(animalAgainstId[animalId].upForMating==false);
//putting up the flag for sale
animalAgainstId[animalId].upForSale=true;
animalAgainstId[animalId].priceForSale=salePrice;
upForSaleList.push(animalId);
//transferring the sale advertisement price to the owner
owner.transfer(msg.value);
}
/**
* function to withdraw a sale advertisement that was put earlier
**/
function withdrawSaleRequest(uint animalId) public
{
require (!isContractPaused);
// the animal id actually belongs to the requester
require(token.ownerOf(animalId)==msg.sender);
// the animal in question is still up for sale
require(animalAgainstId[animalId].upForSale==true);
// change the animal state to not be on sale
animalAgainstId[animalId].upForSale=false;
animalAgainstId[animalId].priceForSale=0;
// remove the animal from sale list
for (uint i=0;i<upForSaleList.length;i++)
{
if (upForSaleList[i]==animalId)
delete upForSaleList[i];
}
}
/**
* function to put mating request in exchange for ethers
**/
function putMatingRequest(uint animalId, uint matePrice) public payable
{
require(!isContractPaused);
require(animalAgainstId[animalId].isSpecial==false);
// the owner of the contract does not need to pay the mate advertisement fees
if (msg.sender!=owner)
{
require(msg.value>=priceForMateAdvertisement);
}
require(token.ownerOf(animalId)==msg.sender);
// an animal in egg phase cannot be put for mating
require(animalAgainstId[animalId].eggPhase==false);
// an animal on sale cannot be put for mating
require(animalAgainstId[animalId].upForSale==false);
// an animal already up for mating cannot be put for mating again
require(animalAgainstId[animalId].upForMating==false);
animalAgainstId[animalId].upForMating=true;
animalAgainstId[animalId].priceForMating=matePrice;
upForMatingList.push(animalId);
// transfer the mating advertisement charges to owner
owner.transfer(msg.value);
}
/**
* withdraw the mating request that was put earlier
**/
function withdrawMatingRequest(uint animalId) public
{
require(!isContractPaused);
require(token.ownerOf(animalId)==msg.sender);
require(animalAgainstId[animalId].upForMating==true);
animalAgainstId[animalId].upForMating=false;
animalAgainstId[animalId].priceForMating=0;
for (uint i=0;i<upForMatingList.length;i++)
{
if (upForMatingList[i]==animalId)
delete upForMatingList[i];
}
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool)
{
// check validity of purchase
if(msg.value.div(weiPerAnimal)<1)
return false;
uint quotient=msg.value.div(weiPerAnimal);
uint actualVal=quotient.mul(weiPerAnimal);
if(msg.value>actualVal)
return false;
else
return true;
}
/**
* function to show how many animals does an address have
**/
function showMyAnimalBalance() public view returns (uint256 tokenBalance)
{
tokenBalance = token.balanceOf(msg.sender);
}
/**
* function to set the new price
* can only be called from owner wallet
**/
function setPriceRate(uint256 newPrice) public onlyOwner returns (bool)
{
weiPerAnimal = newPrice;
}
/**
* function to set the mate advertisement price
* can only be called from owner wallet
**/
function setMateAdvertisementRate(uint256 newPrice) public onlyOwner returns (bool)
{
priceForMateAdvertisement = newPrice;
}
/**
* function to set the sale advertisement price
* can only be called from owner wallet
**/
function setSaleAdvertisementRate(uint256 newPrice) public onlyOwner returns (bool)
{
priceForSaleAdvertisement = newPrice;
}
/**
* function to set the sale advertisement price
* can only be called from owner wallet
**/
function setBuyingCostumeRate(uint256 newPrice) public onlyOwner returns (bool)
{
priceForBuyingCostume = newPrice;
}
/**
* function to get all mating animal ids
**/
function getAllMatingAnimals() public constant returns (uint[])
{
return upForMatingList;
}
/**
* function to get all sale animals ids
**/
function getAllSaleAnimals() public constant returns (uint[])
{
return upForSaleList;
}
/**
* function to change the free animals limit for each user
* can only be called from owner wallet
**/
function changeFreeAnimalsLimit(uint limit) public onlyOwner
{
freeAnimalsLimit = limit;
}
/**
* function to change the owner share on buying transactions
* can only be called from owner wallet
**/
function changeOwnerSharePerThousandForBuying(uint buyshare) public onlyOwner
{
ownerPerThousandShareForBuying = buyshare;
}
/**
* function to change the owner share on mating transactions
* can only be called from owner wallet
**/
function changeOwnerSharePerThousandForMating(uint mateshare) public onlyOwner
{
ownerPerThousandShareForMating = mateshare;
}
/**
* function to pause the contract
* can only be called from owner wallet
**/
function pauseContract(bool isPaused) public onlyOwner
{
isContractPaused = isPaused;
}
/**
* function to remove an animal from egg phase
* can be called from anyone in the member addresses list
**/
function removeFromEggPhase(uint animalId) public
{
for (uint i=0;i<memberAddresses.length;i++)
{
if (memberAddresses[i]==msg.sender)
{
for (uint j=0;j<eggPhaseAnimalIds.length;j++)
{
if (eggPhaseAnimalIds[j]==animalId)
{
delete eggPhaseAnimalIds[j];
}
}
animalAgainstId[animalId].eggPhase = false;
}
}
}
/**
* function to get all children ids of an animal
**/
function getChildrenAgainstAnimalId(uint id) public constant returns (uint[])
{
return childrenIdAgainstAnimalId[id];
}
/**
* function to get all animals in the egg phase list
**/
function getEggPhaseList() public constant returns (uint[])
{
return eggPhaseAnimalIds;
}
/**
* function to get all animals in costume not yet approved list
**/
function getAnimalIdsWithPendingCostume() public constant returns (uint[])
{
return animalIdsWithPendingCostumes;
}
/**
* function to request to buy costume
**/
function buyCostume(uint cId, uint aId) public payable
{
require(msg.value>=priceForBuyingCostume);
require(!isContractPaused);
require(token.ownerOf(aId)==msg.sender);
require(animalAgainstId[aId].costumeId==0);
animalAgainstId[aId].costumeId=cId;
animalIdsWithPendingCostumes.push(aId);
// transfer the mating advertisement charges to owner
owner.transfer(msg.value);
}
/**
* function to approve a pending costume
* can be called from anyone in the member addresses list
**/
function approvePendingCostume(uint animalId) public
{
for (uint i=0;i<memberAddresses.length;i++)
{
if (memberAddresses[i]==msg.sender)
{
for (uint j=0;j<animalIdsWithPendingCostumes.length;j++)
{
if (animalIdsWithPendingCostumes[j]==animalId)
{
delete animalIdsWithPendingCostumes[j];
}
}
}
}
}
/**
* function to add a member that could remove animals from egg phase
* can only be called from owner wallet
**/
function addMember(address member) public onlyOwner
{
memberAddresses.push(member);
}
/**
* function to return the members that could remove an animal from egg phase
**/
function listMembers() public constant returns (address[])
{
return memberAddresses;
}
/**
* function to delete a member from the list that could remove an animal from egg phase
* can only be called from owner wallet
**/
function deleteMember(address member) public onlyOwner
{
for (uint i=0;i<memberAddresses.length;i++)
{
if (memberAddresses[i]==member)
{
delete memberAddresses[i];
}
}
}
/**
* function to update an animal
* can only be called from owner wallet
**/
function updateAnimal(uint animalId, string name, string desc) public
{
require(msg.sender==token.ownerOf(animalId));
animalAgainstId[animalId].name=name;
animalAgainstId[animalId].desc=desc;
token.setAnimalMeta(animalId, name);
}
/**
* function to update an animal
* can only be called from owner wallet
**/
function updateAnimalSpecial(uint animalId, bool isSpecial) public onlyOwner
{
require(msg.sender==token.ownerOf(animalId));
animalAgainstId[animalId].isSpecial=isSpecial;
}
} | you cannot advertise an animal for sale which is in egg phase | require(animalAgainstId[animalId].eggPhase==false);
| 1,305,867 | [
1,
19940,
2780,
31553,
392,
392,
2840,
364,
272,
5349,
1492,
353,
316,
25144,
6855,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
2583,
12,
304,
2840,
23530,
334,
548,
63,
304,
2840,
548,
8009,
23171,
11406,
631,
5743,
1769,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/5/0xCf86e56b395032163dd4Af966500e2F189f29637/sources/contracts/contracts-V6/src/Libraries.sol | Unlock campaign funds equivalent to project reward โ
Unlock the funds for the project | function unlockProjectRewardPostCleanup(
Campaign storage _campaign,
ProjectManager.Project memory _project,
uint256 _taskSubmissionDecisionDisputeTime
) external {
require(
block.timestamp >=
_project.nextMilestone.startGateTimestamp +
_taskSubmissionDecisionDisputeTime
);
FundingsManager.fundUnlockAmount(_campaign.fundings, _project.reward);
}
| 7,070,632 | [
1,
7087,
8965,
284,
19156,
7680,
358,
1984,
19890,
225,
163,
255,
232,
3967,
326,
284,
19156,
364,
326,
1984,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
7186,
4109,
17631,
1060,
3349,
15007,
12,
203,
3639,
17820,
2502,
389,
14608,
16,
203,
3639,
5420,
1318,
18,
4109,
3778,
389,
4406,
16,
203,
3639,
2254,
5034,
389,
4146,
17865,
15861,
1669,
2507,
950,
203,
565,
262,
3903,
288,
203,
3639,
2583,
12,
203,
5411,
1203,
18,
5508,
1545,
203,
7734,
389,
4406,
18,
4285,
49,
18270,
18,
1937,
13215,
4921,
397,
203,
10792,
389,
4146,
17865,
15861,
1669,
2507,
950,
203,
3639,
11272,
203,
203,
3639,
478,
1074,
899,
1318,
18,
74,
1074,
7087,
6275,
24899,
14608,
18,
74,
1074,
899,
16,
389,
4406,
18,
266,
2913,
1769,
203,
565,
289,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity 0.4.24;
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* See https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
// File: contracts/AdvisorsVesting.sol
contract AdvisorsVesting {
using SafeMath for uint256;
modifier onlyV12MultiSig {
require(msg.sender == v12MultiSig, "not owner");
_;
}
modifier onlyValidAddress(address _recipient) {
require(_recipient != address(0) && _recipient != address(this) && _recipient != address(token), "not valid _recipient");
_;
}
uint256 constant internal SECONDS_PER_DAY = 86400;
struct Grant {
uint256 startTime;
uint256 amount;
uint256 vestingDuration;
uint256 vestingCliff;
uint256 daysClaimed;
uint256 totalClaimed;
address recipient;
bool isActive;
}
event GrantAdded(address indexed recipient, uint256 vestingId);
event GrantTokensClaimed(address indexed recipient, uint256 amountClaimed);
event GrantRemoved(address recipient, uint256 amountVested, uint256 amountNotVested);
event ChangedMultisig(address multisig);
ERC20 public token;
mapping (uint256 => Grant) public tokenGrants;
address public v12MultiSig;
uint256 public totalVestingCount;
constructor(ERC20 _token) public {
require(address(_token) != address(0));
v12MultiSig = msg.sender;
token = _token;
}
function addTokenGrant(
address _recipient,
uint256 _startTime,
uint256 _amount,
uint256 _vestingDurationInDays,
uint256 _vestingCliffInDays
)
external
onlyV12MultiSig
onlyValidAddress(_recipient)
{
require(_vestingCliffInDays <= 10*365, "more than 10 years");
require(_vestingDurationInDays <= 25*365, "more than 25 years");
require(_vestingDurationInDays >= _vestingCliffInDays, "Duration < Cliff");
uint256 amountVestedPerDay = _amount.div(_vestingDurationInDays);
require(amountVestedPerDay > 0, "amountVestedPerDay > 0");
// Transfer the grant tokens under the control of the vesting contract
require(token.transferFrom(v12MultiSig, address(this), _amount), "transfer failed");
Grant memory grant = Grant({
startTime: _startTime == 0 ? currentTime() : _startTime,
amount: _amount,
vestingDuration: _vestingDurationInDays,
vestingCliff: _vestingCliffInDays,
daysClaimed: 0,
totalClaimed: 0,
recipient: _recipient,
isActive: true
});
tokenGrants[totalVestingCount] = grant;
emit GrantAdded(_recipient, totalVestingCount);
totalVestingCount++;
}
function getActiveGrants(address _recipient) public view returns(uint256[]){
uint256 i = 0;
uint256[] memory recipientGrants = new uint256[](totalVestingCount);
uint256 totalActive = 0;
// total amount of vesting grants assumed to be less than 100
for(i; i < totalVestingCount; i++){
if(tokenGrants[i].isActive && tokenGrants[i].recipient == _recipient){
recipientGrants[totalActive] = i;
totalActive++;
}
}
assembly {
mstore(recipientGrants, totalActive)
}
return recipientGrants;
}
/// @notice Calculate the vested and unclaimed months and tokens available for `_grantId` to claim
/// Due to rounding errors once grant duration is reached, returns the entire left grant amount
/// Returns (0, 0) if cliff has not been reached
function calculateGrantClaim(uint256 _grantId) public view returns (uint256, uint256) {
Grant storage tokenGrant = tokenGrants[_grantId];
// For grants created with a future start date, that hasn't been reached, return 0, 0
if (currentTime() < tokenGrant.startTime) {
return (0, 0);
}
// Check cliff was reached
uint elapsedTime = currentTime().sub(tokenGrant.startTime);
uint elapsedDays = elapsedTime.div(SECONDS_PER_DAY);
if (elapsedDays < tokenGrant.vestingCliff) {
return (elapsedDays, 0);
}
// If over vesting duration, all tokens vested
if (elapsedDays >= tokenGrant.vestingDuration) {
uint256 remainingGrant = tokenGrant.amount.sub(tokenGrant.totalClaimed);
return (tokenGrant.vestingDuration, remainingGrant);
} else {
uint256 daysVested = elapsedDays.sub(tokenGrant.daysClaimed);
uint256 amountVestedPerDay = tokenGrant.amount.div(uint256(tokenGrant.vestingDuration));
uint256 amountVested = uint256(daysVested.mul(amountVestedPerDay));
return (daysVested, amountVested);
}
}
/// @notice Allows a grant recipient to claim their vested tokens. Errors if no tokens have vested
/// It is advised recipients check they are entitled to claim via `calculateGrantClaim` before calling this
function claimVestedTokens(uint256 _grantId) external {
uint256 daysVested;
uint256 amountVested;
(daysVested, amountVested) = calculateGrantClaim(_grantId);
require(amountVested > 0, "amountVested is 0");
Grant storage tokenGrant = tokenGrants[_grantId];
tokenGrant.daysClaimed = tokenGrant.daysClaimed.add(daysVested);
tokenGrant.totalClaimed = tokenGrant.totalClaimed.add(amountVested);
require(token.transfer(tokenGrant.recipient, amountVested), "no tokens");
emit GrantTokensClaimed(tokenGrant.recipient, amountVested);
}
/// @notice Terminate token grant transferring all vested tokens to the `_grantId`
/// and returning all non-vested tokens to the V12 MultiSig
/// Secured to the V12 MultiSig only
/// @param _grantId grantId of the token grant recipient
function removeTokenGrant(uint256 _grantId)
external
onlyV12MultiSig
{
Grant storage tokenGrant = tokenGrants[_grantId];
require(tokenGrant.isActive, "is not active");
address recipient = tokenGrant.recipient;
uint256 daysVested;
uint256 amountVested;
(daysVested, amountVested) = calculateGrantClaim(_grantId);
uint256 amountNotVested = (tokenGrant.amount.sub(tokenGrant.totalClaimed)).sub(amountVested);
require(token.transfer(recipient, amountVested));
require(token.transfer(v12MultiSig, amountNotVested));
tokenGrant.startTime = 0;
tokenGrant.amount = 0;
tokenGrant.vestingDuration = 0;
tokenGrant.vestingCliff = 0;
tokenGrant.daysClaimed = 0;
tokenGrant.totalClaimed = 0;
tokenGrant.recipient = address(0);
tokenGrant.isActive = false;
emit GrantRemoved(recipient, amountVested, amountNotVested);
}
function currentTime() public view returns(uint256) {
return block.timestamp;
}
function tokensVestedPerDay(uint256 _grantId) public view returns(uint256) {
Grant storage tokenGrant = tokenGrants[_grantId];
return tokenGrant.amount.div(uint256(tokenGrant.vestingDuration));
}
function changeMultiSig(address _newMultisig)
external
onlyV12MultiSig
onlyValidAddress(_newMultisig)
{
v12MultiSig = _newMultisig;
emit ChangedMultisig(_newMultisig);
}
} | total amount of vesting grants assumed to be less than 100 | function getActiveGrants(address _recipient) public view returns(uint256[]){
uint256 i = 0;
uint256[] memory recipientGrants = new uint256[](totalVestingCount);
uint256 totalActive = 0;
for(i; i < totalVestingCount; i++){
if(tokenGrants[i].isActive && tokenGrants[i].recipient == _recipient){
recipientGrants[totalActive] = i;
totalActive++;
}
}
assembly {
mstore(recipientGrants, totalActive)
}
return recipientGrants;
}
| 987,896 | [
1,
4963,
3844,
434,
331,
10100,
25638,
12034,
358,
506,
5242,
2353,
2130,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
11960,
29598,
12,
2867,
389,
20367,
13,
1071,
1476,
1135,
12,
11890,
5034,
63,
5717,
95,
203,
3639,
2254,
5034,
277,
273,
374,
31,
203,
3639,
2254,
5034,
8526,
3778,
8027,
29598,
273,
394,
2254,
5034,
8526,
12,
4963,
58,
10100,
1380,
1769,
203,
3639,
2254,
5034,
2078,
3896,
273,
374,
31,
203,
3639,
364,
12,
77,
31,
277,
411,
2078,
58,
10100,
1380,
31,
277,
27245,
95,
203,
5411,
309,
12,
2316,
29598,
63,
77,
8009,
291,
3896,
597,
1147,
29598,
63,
77,
8009,
20367,
422,
389,
20367,
15329,
203,
7734,
8027,
29598,
63,
4963,
3896,
65,
273,
277,
31,
203,
7734,
2078,
3896,
9904,
31,
203,
5411,
289,
203,
3639,
289,
203,
3639,
19931,
288,
203,
5411,
312,
2233,
12,
20367,
29598,
16,
2078,
3896,
13,
203,
3639,
289,
203,
3639,
327,
8027,
29598,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
/**
*Submitted for verification at Etherscan.io on 2020-08-14
*/
pragma solidity ^0.5.0;
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
//
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Safe Math Library
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a); c = a - b; } function safeMul(uint a, uint b) public pure returns (uint c) { c = a * b; require(a == 0 || c / a == b); } function safeDiv(uint a, uint b) public pure returns (uint c) { require(b > 0);
c = a / b;
}
}
contract eMinus is ERC20Interface, SafeMath {
string public name;
string public symbol;
uint8 public decimals; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor() public {
name = "Ethereum Minus";
symbol = "eMinus";
decimals = 18;
_totalSupply = 1000000000000000000000000000000;
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function totalSupply() public view returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
} | * Constrctor function Initializes contract with initial supply tokens to the creator of the contract/ | constructor() public {
name = "Ethereum Minus";
symbol = "eMinus";
decimals = 18;
_totalSupply = 1000000000000000000000000000000;
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
| 249,771 | [
1,
442,
701,
30206,
445,
10188,
3128,
6835,
598,
2172,
14467,
2430,
358,
326,
11784,
434,
326,
6835,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
3885,
1435,
1071,
288,
203,
3639,
508,
273,
315,
41,
18664,
379,
5444,
407,
14432,
203,
3639,
3273,
273,
315,
73,
18434,
14432,
203,
3639,
15105,
273,
6549,
31,
203,
3639,
389,
4963,
3088,
1283,
273,
2130,
12648,
12648,
12648,
2787,
31,
203,
540,
203,
3639,
324,
26488,
63,
3576,
18,
15330,
65,
273,
389,
4963,
3088,
1283,
31,
203,
3639,
3626,
12279,
12,
2867,
12,
20,
3631,
1234,
18,
15330,
16,
389,
4963,
3088,
1283,
1769,
203,
565,
289,
203,
377,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/1/0x9a50742da823F92575b30dBAE0FcAEF25aE0186f/sources/WithdrawalDelayer.sol | * @dev Allows the pendingGovernance address to finalize the transfer./ | function claimEmergencyCouncil() public override {
require(
msg.sender == pendingEmergencyCouncil,
"WithdrawalDelayer::claimEmergencyCouncil: ONLY_PENDING_GOVERNANCE"
);
_emergencyCouncil = pendingEmergencyCouncil;
pendingEmergencyCouncil = address(0);
emit NewEmergencyCouncil(_emergencyCouncil);
}
| 4,251,241 | [
1,
19132,
326,
4634,
43,
1643,
82,
1359,
1758,
358,
12409,
326,
7412,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
7516,
1514,
24530,
39,
465,
71,
330,
1435,
1071,
3849,
288,
203,
3639,
2583,
12,
203,
5411,
1234,
18,
15330,
422,
4634,
1514,
24530,
39,
465,
71,
330,
16,
203,
5411,
315,
1190,
9446,
287,
2837,
1773,
2866,
14784,
1514,
24530,
39,
465,
71,
330,
30,
20747,
67,
25691,
67,
43,
12959,
50,
4722,
6,
203,
3639,
11272,
203,
3639,
389,
351,
24530,
39,
465,
71,
330,
273,
4634,
1514,
24530,
39,
465,
71,
330,
31,
203,
3639,
4634,
1514,
24530,
39,
465,
71,
330,
273,
1758,
12,
20,
1769,
203,
3639,
3626,
1166,
1514,
24530,
39,
465,
71,
330,
24899,
351,
24530,
39,
465,
71,
330,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
๏ปฟ// ะกะพัะตัะฐะตะผะพััั ะณะปะฐะณะพะปะพะฒ (ะธ ะพัะณะปะฐะณะพะปัะฝัั
ัะฐััะตะน ัะตัะธ) ั ะฟัะตะดะปะพะถะฝัะผ
// ะฟะฐััะตัะฝะพะผ.
// LC->07.08.2018
facts ะณะป_ะฟัะตะดะป language=Russian
{
arity=3
//violation_score=-5
generic
return=boolean
}
#define ะะ_ะะะค(v) ะธะฝัะธะฝะธัะธะฒ:v{}, ะณะปะฐะณะพะป:v{}
#region ะัะตะดะปะพะณ_ะ
// ------------------- ะก ะะ ะะะะะะะ 'ะ' ---------------------------
#region ะัะตะดะปะพะถะฝัะน
// ะะปะฐะณะพะปั ะธ ะพัะณะปะฐะณะพะปัะฝัะต ัะฐััะธ ัะตัะธ, ะฟัะธัะพะตะดะธะฝัััะธะต
// ะฟัะตะดะปะพะถะฝะพะต ะดะพะฟะพะปะฝะตะฝะธะต ั ะฟัะตะดะปะพะณะพะผ ะ ะธ ััั. ะฒ ะฟัะตะดะปะพะถะฝะพะผ ะฟะฐะดะตะถะต.
wordentry_set ะะป_ะ_ะัะตะดะป =
{
rus_verbs:ะฒะทะพัะฒะฐัััั{}, // ะ ะะฐะณะตััะฐะฝะต ะฒะทะพัะฒะฐะปัั ะฐะฒัะพะผะพะฑะธะปั
// ะฒะตัะฝััั ะฟะพัะปะต ะฟะตัะตะบะพะผะฟะธะปััะธะธ rus_verbs:ะฟะพะดะพัะพะถะฐัั{}, // ะ ะะฐะณะตััะฐะฝะต ะฟะพะดะพัะพะถะฐะป ั
ะปะตะฑ
rus_verbs:ะฒะพะตะฒะฐัั{}, // ะะพะตะฒะฐะป ะฒะพ ะคัะฐะฝัะธะธ.
rus_verbs:ัััะฐัั{}, // ะฃััะฐะปะธ ะฒ ะดะพัะพะณะต?
rus_verbs:ะธะทะฝัะฒะฐัั{}, // ะ ะะพะฝะดะพะฝะต ะงะตััะธะปะปั ะธะทะฝัะฒะฐะป ะพั ะฝะตัะตัะฟะตะฝะธั.
rus_verbs:ัะตัะธัั{}, // ะงัะพ ัะตัะฐั ะฒ ะฟัะฐะฒะธัะตะปัััะฒะต?
rus_verbs:ะฒััะบะฐะบะธะฒะฐัั{}, // ะะดะธะฝ ะธะท ะฑะพะนัะพะฒ ะฝะฐ ัะปะธัั ะฒััะบะฐะบะธะฒะฐะตั.
rus_verbs:ะพะฑััะพััั{}, // ะ ะดะตะนััะฒะธัะตะปัะฝะพััะธ ะถะต ะดะตะปะพ ะพะฑััะพัะปะพ ะฝะต ัะฐะบ.
rus_verbs:ะฟะพะดัะผะฐัััั{},
rus_verbs:ะฟะพะตั
ะฐัั{}, // ะฟะพะตะดะตะผ ะฒ ัะฐะบัะธ!
rus_verbs:ัะตั
ะฐัั{}, // ะพะฝ ัะตั
ะฐะป ะฒ ัะฐะบัะธ
rus_verbs:ะฟัะธะฑััั{}, // ะพะฝะธ ะฟัะธะฑัะปะธ ะฒ ะบะฐัะตััะฒะต ะฝะตะทะฐะฒะธัะธะผัั
ะฝะฐะฑะปัะดะฐัะตะปะตะน
rus_verbs:ะะะะะงะะขะฌ{},
rus_verbs:ะะะะะงะะขะฌ{},
rus_verbs:ะะะะะงะะขะฌะกะฏ{},
rus_verbs:ะะะะะงะะขะฌะกะฏ{},
rus_verbs:ะะะ ะฏะะะขะฌะกะฏ{},
rus_verbs:ะะะ ะฏะะะขะฌะกะฏ{},
rus_verbs:ะะะะะะฏะขะฌะกะฏ{}, // ะฟะพะฒะฐะปัะฒัะธัั ะฒ ัะฝะตะณั, ะฑะตะถะฐัั ะพะฑัะฐัะฝะพ ะฒ ัะตะฟะปะพ.
rus_verbs:ะะะะ ะซะะะขะฌ{}, // ะะพ ะผะฝะพะณะธั
ะผะตััะฐั
ะตะต ะฟะพะบััะฒะฐะปะธ ััะตัะธะฝั, ะฝะฐัะพััั ะธ ะดะพะฒะพะปัะฝะพ ะฟะปะพัะบะธะต ะฒััััะฟั. (ะะะะ ะซะะะขะฌ)
rus_verbs:ะะ ะะะะะะขะฌ{}, // ะกะธะฝะธะน ะปัั ะธัะบัะธะปัั ะฑะตะปัะผะธ ะฟััะฝะฐะผะธ ะธ ะฟัะพะถะธะณะฐะป ะฒ ะทะตะผะปะต ะดัะผัััััั ะฑะพัะพะทะดั. (ะะ ะะะะะะขะฌ)
rus_verbs:ะะซะงะะขะฌ{}, // ะ ะพะณัะพะผะฝะพะน ะบััะต ัะตะป ะถะฐะปะพะฑะฝะพ ะผััะฐะปะธ ะทะฐะดะฐะฒะปะตะฝะฝัะต ัััะฟะฐะผะธ ะธ ัะฐะฝะตะฝัะต ะฑะธะทะพะฝั. (ะะซะงะะขะฌ)
rus_verbs:ะ ะะะะะะะะงะะขะฌ{}, // ะญัะธ ัััะตััะฒะฐ ะพะฑััะฝะพ ัะฐะทะฑะพะนะฝะธัะฐะปะธ ะฒ ััะตั
ััะฐั
ะผะธะปัั
ะพัััะดะฐ (ะ ะะะะะะะะงะะขะฌ)
rus_verbs:ะะะฏะงะะขะฌ{}, // ะ ะพัะดะฐะปะตะฝะธะธ ะผะฐััะธะปะธ ะพะณัะพะผะฝัะต ัะตััะต ัััะธ ะผะฐััะพะดะพะฝัะพะฒ ะธ ะผะฐะผะพะฝัะพะฒ ั ะธะทะพะณะฝัััะผะธ ะฑะธะฒะฝัะผะธ. (ะะะฏะงะะขะฌ/ะะะะะฏะงะะขะฌ)
rus_verbs:ะะะะะฏะงะะขะฌ{},
rus_verbs:ะะะกะขะะกะฌ{}, // ะะพะฝะธ ะฝะตัะปะธัั ะฒะฟะตัะตะด ะฒ ัะฒะพะฑะพะดะฝะพะผ ะธ ะปะตะณะบะพะผ ะณะฐะปะพะฟะต (ะะะกะขะะกะฌ)
rus_verbs:ะะะะซะขะฌ{}, // ะะฝะธ ะฝะฐะดะตัะปะธัั ะทะฐััะฐัั "ะผะตะดะฒะตะถะธะน ะฝะฐัะพะด" ะฒัะฐัะฟะปะพั
ะธ ะดะพะฑััั ะฒ ะฑะพั ะณะพะปะพะฒั ะฒะตะปะธัะฐะนัะตะณะพ ะธะท ะฒะพะธะฝะพะฒ. (ะะะะซะขะฌ)
rus_verbs:ะกะะฃะกะขะะขะฌ{}, // ะัะตะผั ะพั ะฒัะตะผะตะฝะธ ะณัะพั
ะพั ะธะปะธ ะฒะพะฟะปั ะพะฑััะฒะปัะปะธ ะพ ัะฟััะตะฝะฝะพะน ะณะดะต-ัะพ ะฒะพ ะดะฒะพััะต ะปะพะฒััะบะต. (ะกะะฃะกะขะะขะฌ)
rus_verbs:ะะะ ะะะะะซะะะขะฌะกะฏ{}, // ะะฝะฐ ััะทะธะปะฐ ะณะปะฐะทะฐ, ะฝะฐ ะปะธัะต ะตะต ััะฐะปะฐ ะพะฑัะฐะทะพะฒัะฒะฐัััั ะผะฐัะบะฐ ะฑะตะทัะผะธั. (ะะะ ะะะะะซะะะขะฌะกะฏ)
rus_verbs:ะะะจะะขะฌ{}, // ะฒ ััะพะผ ัะฐะนะพะฝะต ะบะธัะผั ะบะธัะตะปะธ ัะฐะทะฑะพะนะฝะธะบะธ ะธ ะดัะฐะบะพะฝั. (ะะะจะะขะฌ)
rus_verbs:ะะซะจะะขะฌ{}, // ะะฝะฐ ััะถะตะปะพ ะดััะฐะปะฐ ะฒ ัะธัะบะฐั
ะณะฝะตะฒะฐ (ะะซะจะะขะฌ)
rus_verbs:ะะะะะะะขะฌ{}, // ัะพั ะทะฐะดะตะฒะฐะป ะฒ ะฝะตะผ ะบะฐะบัั-ัะพ ััััะฝั (ะะะะะะะขะฌ)
rus_verbs:ะฃะกะขะฃะะะขะฌ{}, // ะขะฐะบ ััะพ ัะตะฟะตัั ััััะฟะธ ะผะฝะต ะฒ ััะพะผ. (ะฃะกะขะฃะะะขะฌ)
rus_verbs:ะขะะ ะฏะขะฌ{}, // ะฅะพัั ะพะฝ ั
ะพัะพัะพ ะฟะธัะฐะปัั, ะพะฝ ัะตััะป ะฒ ะฒะตัะต (ะขะะ ะฏะขะฌ/ะะะขะะ ะฏะขะฌ)
rus_verbs:ะะพะขะะ ะฏะขะฌ{},
rus_verbs:ะฃะขะะ ะฏะขะฌ{},
rus_verbs:ะ ะะกะขะะ ะฏะขะฌ{},
rus_verbs:ะกะะซะะะขะฌะกะฏ{}, // ะกะปะพะฒะฝะพ ะผะตะดะปะตะฝะฝะพ ัะผัะบะฐััะธะนัั ะฒะพ ัะฝะต ะณะปะฐะท, ะพัะฒะตัััะธะต ะผะตะดะปะตะฝะฝะพ ะทะฐะบััะฒะฐะปะพัั. (ะกะะซะะะขะฌะกะฏ/ะกะะะะะฃะขะฌะกะฏ, + ะพะฑะพัะพั ั ะกะะะะะ/ะะฃะะขะ + ะฒะธะฝ.ะฟ.)
rus_verbs:ะกะะะะะฃะขะฌะกะฏ{},
rus_verbs:ะ ะะะะะ ะะจะะขะฌ{}, // ะะพะปัั ะฝะต ัะทะฝะฐะป ะฝะธะบะฐะบะธั
ะพัะดะตะปัะฝัั
ัะปะพะฒ, ะฝะพ ะทะฒัะบะธ ะธ ะฒะทะฐะธะผะพะดะตะนััะฒัััะฐั ะฒััะพัะฐ ัะพะฝะพะฒ ัะฐะทะฒะพัะพัะธะปะธ ััะพ-ัะพ ะฒ ะตะณะพ ะฟะฐะผััะธ. (ะ ะะะะะ ะะจะะขะฌ)
rus_verbs:ะะ ะะกะขะะฏะขะฌ{}, // ะะฝ ะฟะพะดะฝัะปัั ะธ ะฝะตะบะพัะพัะพะต ะฒัะตะผั ะฟัะพััะพัะป ะฒ ะทะฐะดัะผัะธะฒะพััะธ. (ะะ ะะกะขะะฏะขะฌ,ะะซะกะขะะฏะขะฌ,ะะะกะขะะฏะขะฌ)
rus_verbs:ะะซะกะขะะฏะขะฌ{},
rus_verbs:ะะะกะขะะฏะขะฌ{},
rus_verbs:ะะะะะกะะขะฌ{}, // ะะฝ ะฟะพะดะฝัะป ะธ ะฒะทะฒะตัะธะป ะฒ ััะบะต ะพะดะธะฝ ะธะท ัะพะณะพะฒ ะธะทะพะฑะธะปะธั. (ะะะะะกะะขะฌ/ะะะะะจะะะะขะฌ)
rus_verbs:ะะะะะจะะะะขะฌ{},
rus_verbs:ะะ ะะะคะะะะขะฌ{}, // ะะฝ ะธ ัะพะณะดะฐ ะฝะต ัะฟะฐะดะตั, ะฐ ะฑัะดะตั ะดัะตะนัะพะฒะฐัั ะฒ ะพัะฑัะฐััะฒะฐะตะผะพะน ะดะธัะบะพะผ ัะตะฝะธ. (ะะ ะะะคะะะะขะฌ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฑัััััะน{}, // ะะธัะตะปั ะฑัััั ะฒ ะฟัะธะณะพัะพะฒะปะตะฝะธะธ
rus_verbs:ะฟัะธะทะฒะฐัั{}, // ะ ะะตะฝั ะะพะปะธ ะฑะตะปะพัััะพะฒ ะฟัะธะทะฒะฐะปะธ ะฟะพะฑะพัะพัั ัััะฐั
ะธ ะปะตะฝั
rus_verbs:ะฟัะธะทัะฒะฐัั{},
rus_verbs:ะะะกะะะะฌะะะะะขะฌะกะฏ{}, // ััะธะผะธ ะดะตะฝัะณะฐะผะธ ัะผะพะณั ะฒะพัะฟะพะปัะทะพะฒะฐัััั ะฒ ะพัะฟััะบะต (ะะะกะะะะฌะะะะะขะฌะกะฏ)
rus_verbs:ะะะะะฃะ ะะ ะะะะขะฌ{}, // ะะฐัะธ ะบะปัะฑั ะผะพะณะปะธ ะฑั ะฒ ะะฝะณะปะธะธ ะบะพะฝะบััะธัะพะฒะฐัั ั ะปะธะดะตัะฐะผะธ (ะะะะะฃะ ะะ ะะะะขะฌ)
rus_verbs:ะะะะะะขะฌ{}, // ะะผะตัะธะบะฐะฝัะบัั ัะตะปะตะฒะตะดัััั ะฟะพะทะฒะฐะปะธ ะทะฐะผัะถ ะฒ ะฟััะผะพะผ ััะธัะต (ะะะะะะขะฌ)
rus_verbs:ะะซะฅะะะะขะฌ{}, // ะ ะฐะนะพะฝะฝัะต ะณะฐะทะตัั ะะพะปะพะณะพะดัะธะฝั ะฑัะดัั ะฒัั
ะพะดะธัั ะฒ ัะฒะตัะต ะธ ะฝะพะฒะพะผ ัะพัะผะฐัะต (ะะซะฅะะะะขะฌ)
rus_verbs:ะ ะะะะะ ะะงะะะะขะฌะกะฏ{}, // ะกัะถะตั ััะฝัะตะทะธ ัะฐะทะฒะพัะฐัะธะฒะฐะตััั ะฒ ะดะฒัั
ะผะธัะฐั
(ะ ะะะะะ ะะงะะะะขะฌะกะฏ)
rus_verbs:ะะะกะฃะะะขะฌ{}, // ะ ะกะฐะผะฐัะต ะพะฑััะดะธะปะธ ะฟะตััะฟะตะบัะธะฒั ะธะฝัะพัะผะฐัะธะทะฐัะธะธ ะฒะตัะตัะธะฝะฐัะธะธ (ะะะกะฃะะะขะฌ)
rus_verbs:ะะะะ ะะะะฃะขะฌ{}, // ะพะฝะฐ ัะธะปัะฝะพ ะฒะทะดัะพะณะฝัะปะฐ ะฒะพ ัะฝะต (ะะะะ ะะะะฃะขะฌ)
rus_verbs:ะะ ะะะกะขะะะะฏะขะฌ{}, // ะกะตะฝะฐัะพัั, ะฟัะตะดััะฐะฒะปัััะธะต ะฒ ะะพะผะธัะตัะต ะฟะพ ัะฐะทะฒะตะดะบะต ะพะฑะต ะฟะฐััะธะธ, ะฟะพะดะดะตัะถะฐะปะธ ััั ะฟัะพััะฑั (ะะ ะะะกะขะะะะฏะขะฌ)
rus_verbs:ะะะะะะะ ะะะะขะฌ{}, // ะฒ ั
ะธะผะธัะตัะบะพะผ ัะพััะฐะฒะต ะพะดะฝะพะน ะธะท ะฟะปะฐะฝะตั ะดะพะผะธะฝะธััะตั ะผะตัะฐะฝ (ะะะะะะะ ะะะะขะฌ)
rus_verbs:ะะขะะ ะซะขะฌ{}, // ะััะผ ะพัะบััะป ะฒ ะะพัะบะฒะต ัะพะฑััะฒะตะฝะฝัะน ัััะธััะธัะตัะบะธะน ะพัะธั (ะะขะะ ะซะขะฌ)
rus_verbs:ะะะะะะะขะฌ{}, // ะ ะััะบะธะฝัะบะพะผ ะผัะทะตะต ะฟะพะบะฐะทะฐะปะธ ะทะพะปะพัะพ ะธะฝะบะพะฒ (ะะะะะะะขะฌ)
rus_verbs:ะฝะฐะฑะปัะดะฐัั{}, // ะะฐะฑะปัะดะฐะตะผัะน ะฒ ะพััะฐะถะตะฝะธะธ ัะฒะตั ะธะทะปััะตะฝะธั
rus_verbs:ะะ ะะะะขะะขะฌ{}, // ะััะฟะฝัะน ะฐััะตัะพะธะด ะฟัะพะปะตัะตะป ะฒ ะฝะตะฟะพััะตะดััะฒะตะฝะฝะพะน ะฑะปะธะทะพััะธ ะพั ะะตะผะปะธ (ะะ ะะะะขะะขะฌ)
rus_verbs:ะ ะะกะกะะะะะะะขะฌ{}, // ะ ะะฐะณะตััะฐะฝะต ัะฐััะปะตะดััั ัะฑะธะนััะฒะพ ัะตะดะตัะฐะปัะฝะพะณะพ ััะดัะธ (ะ ะะกะกะะะะะะะขะฌ)
rus_verbs:ะะะะะะะะะะขะฌะกะฏ{}, // ะ ะะตะผะตัะพะฒัะบะพะน ะพะฑะปะฐััะธ ะฒะพะทะพะฑะฝะพะฒะธะปะพัั ะดะฒะธะถะตะฝะธะต ะฟะพ ััะฐััะฐะผ ะผะตะถะดัะฝะฐัะพะดะฝะพะณะพ ะทะฝะฐัะตะฝะธั (ะะะะะะะะะะขะฌะกะฏ)
rus_verbs:ะะะะะะะขะฌะกะฏ{}, // ะธะทะผะตะฝะธะปะฐัั ะพะฝะฐ ะฒะพ ะฒัะตะผ (ะะะะะะะขะฌะกะฏ)
rus_verbs:ะกะะะ ะะะขะฌ{}, // ะทะฐ ัะธัะพะบะธะผ ะพะบะฝะพะผ ะบะพะผะฝะฐัั ะณะพัะพะด ัะฒะตัะบะฐะป ะฒะพ ััะผะต ัะฐะทะฝะพัะฒะตัะฝัะผะธ ะพะณะฝัะผะธ (ะกะะะ ะะะขะฌ)
rus_verbs:ะกะะะะงะะขะฌะกะฏ{}, // ะ ะ ะธะผะต ัะบะพะฝัะฐะปัั ัะตะถะธัััั ะทะฝะฐะผะตะฝะธัะพะณะพ ัะตัะธะฐะปะฐ ยซะกะฟัััยป (ะกะะะะงะะขะฌะกะฏ)
rus_verbs:ะะ ะฏะขะะขะฌะกะฏ{}, // Cะบััััะต ัะฟััะฝะธะบะธ ะฟััััััั ะฒ ะบะพะปััะฐั
ะกะฐัััะฝะฐ (ะะ ะฏะขะะขะฌะกะฏ)
rus_verbs:ะะซะะซะะะขะฌ{}, // ััะพั ัะตะปะพะฒะตะบ ะฒัะตะณะดะฐ ะฒัะทัะฒะฐะป ะฒะพ ะผะฝะต ะฒะพัั
ะธัะตะฝะธะต (ะะซะะซะะะขะฌ)
rus_verbs:ะะซะะฃะกะขะะขะฌ{}, // ะะทะฑะธัะฐัะตะปัะฝัะต ะฑัะปะปะตัะตะฝะธ ะผะพะณัั ะฒัะฟัััะธัั ะฒ ัะพัะผะต ะฑัะพัััั (ะะซะะฃะกะขะะขะฌ)
rus_verbs:ะะะงะะะะขะฌะกะฏ{}, // ะ ะะพัะบะฒะต ะฝะฐัะธะฝะฐะตััั ยซะผะฐัั ะฒ ะทะฐัะธัั ะดะตัะตะนยป (ะะะงะะะะขะฌะกะฏ)
rus_verbs:ะะะกะขะ ะะะะขะฌ{}, // ะ ะะฐะณะตััะฐะฝะต ะทะฐัััะตะปะธะปะธ ะฟัะตะฟะพะดะฐะฒะฐัะตะปั ะผะตะดัะตัะต (ะะะกะขะ ะะะะขะฌ)
rus_verbs:ะฃะ ะะะะฏะขะฌ{}, // ะะพัะทะฐะบะฐะทัะธะบะพะฒ ััะฐะฒะฝััั ะฒ ะฟัะฐะฒะฐั
ั ะฟะพััะฐะฒัะธะบะฐะผะธ (ะฃะ ะะะะฏะขะฌ)
rus_verbs:ะฟัะพะผะฐั
ะฝััััั{}, // ะฒ ะฟะตัะฒะพะน ะฟะพะปะพะฒะธะฝะต ะฝะตะฒะตัะพััะฝัะผ ะพะฑัะฐะทะพะผ ะฟัะพะผะฐั
ะฝัะปัั ัะบั-ัะพัะฒะฐัะด ะผะพัะบะพะฒัะบะพะณะพ ะฆะกะะ
rus_verbs:ะะะซะะ ะะขะฌ{}, // "ะ ัะฑะธะฝ" ัะตะฝัะฐัะธะพะฝะฝะพ ะพะฑัะณัะฐะป ะฒ ะะฐะดัะธะดะต ะฒัะพััั ะบะพะผะฐะฝะดั ะัะฟะฐะฝะธะธ (ะะะซะะ ะะขะฌ)
rus_verbs:ะะะะฎะงะะขะฌ{}, // ะ ะงะตะปัะฑะธะฝัะบะพะน ะพะฑะปะฐััะธ ะฒะบะปััะตะฝ ะฐะฒะฐัะธะนะฝัะน ัะพัะผะธะฝะณ (ะะะะฎะงะะขะฌ)
rus_verbs:ะฃะงะะกะขะะขะฌะกะฏ{}, // ะ ัะตะปะฐั
ะะฐะปะฐะบะพะฒัะบะพะณะพ ัะฐะนะพะฝะฐ ััะฐััะธะปะธัั ัะปััะฐะธ ะฟะพะดะถะพะณะพะฒ ััะพะณะพะฒ ัะตะฝะฐ (ะฃะงะะกะขะะขะฌะกะฏ)
rus_verbs:ะกะะะกะขะ{}, // ะ ะะฒัััะฐะปะธะธ ัะฟะฐัะปะธ ะฟะพะฒะธััะตะณะพ ะฝะฐ ะฟัะพะฒะพะดะต ะบะพัััะฝะฐ (ะกะะะกะขะ)
rus_verbs:ะะซะะะกะขะฌ{}, // ะัะดะตะปัะฝัะต ััะฐะณะผะตะฝัั ะดะพััะธะณะปะธ ะทะตะผะปะธ, ะฒัะฟะฐะฒ ะฒ ะฒะธะดะต ะผะตัะตะพัะธัะฝะพะณะพ ะดะพะถะดั (ะะซะะะกะขะฌ)
rus_verbs:ะะะะ ะะะะขะฌ{}, // ะ ะะพะฝะดะพะฝะต ะฝะฐะณัะฐะดะธะปะธ ะปะฐััะตะฐัะพะฒ ะฟัะตะผะธะธ Brit Awards (ะะะะ ะะะะขะฌ)
rus_verbs:ะะขะะ ะซะขะฌะกะฏ{}, // ะฒ ะะพัะบะฒะต ะพัะบััะปัั ะฟะตัะฒัะน ะผะตะถะดัะฝะฐัะพะดะฝัะน ะบะธะฝะพัะตััะธะฒะฐะปั
rus_verbs:ะะะะะะะะขะฌะกะฏ{}, // ะฒะพ ะผะฝะต ะฟะพะดะฝะธะผะฐะปะพัั ัะฐะทะดัะฐะถะตะฝะธะต
rus_verbs:ะะะะะ ะจะะขะฌะกะฏ{}, // ะ ะัะฐะปะธะธ ะทะฐะฒะตััะธะปัั ััะฐะดะธัะธะพะฝะฝัะน ะะตะฝะตัะธะฐะฝัะบะธะน ะบะฐัะฝะฐะฒะฐะป (ะะะะะ ะจะะขะฌะกะฏ)
ะธะฝัะธะฝะธัะธะฒ:ะฟัะพะฒะพะดะธัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะัะทะฑะฐััะบะธะต ะดะตะฟััะฐัั ะฟัะพะฒะพะดัั ะฒ ะะตะผะตัะพะฒะต ะฟัะธะตะผ ะณัะฐะถะดะฐะฝ
ะณะปะฐะณะพะป:ะฟัะพะฒะพะดะธัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะฟัะพะฒะพะดั{},
rus_verbs:ะพััััััะฒะพะฒะฐัั{}, // ะฅะพะทัะนะบะฐ ะบะฒะฐััะธัั ะฒ ััะพั ะผะพะผะตะฝั ะพััััััะฒะพะฒะฐะปะฐ
rus_verbs:ะดะพะปะพะถะธัั{}, // ะพะฑ ะธัะพะณะฐั
ัะฒะพะตะณะพ ะฒะธะทะธัะฐ ะพะฝ ะฝะฐะผะตัะตะฝ ะดะพะปะพะถะธัั ะฒ ะฐะผะตัะธะบะฐะฝัะบะพะผ ัะตะฝะฐัะต ะธ ะะตะปะพะผ ะดะพะผะต (ะะะะะะะขะฌ ะะ, ะ ะฟัะตะดะป)
rus_verbs:ะะะะะะะขะฌะกะฏ{}, // ะ ะญะนะปะฐัะต ะธะทะดะตะฒะฐัััั ะฝะฐะด ัััะธััะฐะผะธ (ะะะะะะะขะฌะกะฏ ะ ะฟัะตะดะป)
rus_verbs:ะะะ ะฃะจะะขะฌ{}, // ะ ะฝะตัะบะพะปัะบะธั
ัะตะณะธะพะฝะฐั
ะฝะฐัััะตะฝะพ ะฝะฐะทะตะผะฝะพะต ััะฐะฝัะฟะพััะฝะพะต ัะพะพะฑัะตะฝะธะต (ะะะ ะฃะจะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะะะะะขะฌ{}, // ะดะฐะปะตะบะพ ะฒะฝะธะทั ะฒะพ ััะผะต ะฑะตะถะฐะปะฐ ะฝะตะฒะธะดะธะผะฐั ัะตะบะฐ (ะะะะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะกะะะ ะะขะฌะกะฏ{}, // ะะผะธััะธะน ะพะณะปัะดะตะป ัะพะฑัะฐะฒัะธั
ัั ะฒะพ ะดะฒะพัะต ะผะฐะปััะธัะตะบ (ะกะะะ ะะขะฌะกะฏ ะ ะฟัะตะดะป)
rus_verbs:ะะะกะะซะจะะขะฌะกะฏ{}, // ะดะฐะปะตะบะพ ะฒะฒะตัั
ั ะฒะพ ััะผะต ะฟะพัะปััะฐะปัั ะพัะฒะตั (ะะะกะะซะจะะขะฌะกะฏ ะ ะฟัะตะดะป)
rus_verbs:ะะะะะะะขะฌะกะฏ{}, // ะฒะพ ะดะฒะพัะต ะฟะพะบะฐะทะฐะปะฐัั ะฒััะพะบะฐั ัะธะณััะฐ (ะะะะะะะขะฌะกะฏ ะ ะฟัะตะดะป)
rus_verbs:ะฃะะซะะะฃะขะฌะกะฏ{}, // ะะผะธััะธะน ะณะพััะบะพ ัะปัะฑะฝัะปัั ะฒะพ ััะผะต (ะฃะะซะะะฃะขะฌะกะฏ ะ ะฟัะตะดะป)
rus_verbs:ะขะฏะะฃะขะฌะกะฏ{}, // ัะฑะตะถะธัะฐ ััะฝัะปะธัั ะฒะพ ะฒัะตั
ะฝะฐะฟัะฐะฒะปะตะฝะธัั
(ะขะฏะะฃะขะฌะกะฏ ะ ะฟัะตะดะป)
rus_verbs:ะ ะะะะขะฌ{}, // ะ ะฐะผะตัะธะบะฐะฝัะบะพะผ ัะฝะธะฒะตััะธัะตัะต ัะฐะฝะธะปะธ ัะตะปะพะฒะตะบะฐ (ะ ะะะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะะะฅะะะขะะขะฌ{}, // ะะธัะฐัั ะพัะฒะพะฑะพะดะธะปะธ ะบะพัะฐะฑะปั, ะทะฐั
ะฒะฐัะตะฝะฝัะน ะฒ ะะฒะธะฝะตะนัะบะพะผ ะทะฐะปะธะฒะต (ะะะฅะะะขะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะ ะะะะะะะขะฌะกะฏ{}, // ะปัะดะธ ัะฐะทะฑะตะณะฐะปะธัั ะฒะพ ะฒัะตั
ะฝะฐะฟัะฐะฒะปะตะฝะธัั
(ะ ะะะะะะะขะฌะกะฏ ะ ะฟัะตะดะป)
rus_verbs:ะะะะะกะะฃะขะฌ{}, // ะฒะพ ะฒัะตะผ ะดะพะผะต ะฟะพะณะฐั ัะฒะตั (ะะะะะกะะฃะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะะะจะะะะะะขะฌะกะฏ{}, // ะะผะธััะธะน ะฟะพัะตะฒะตะปะธะปัั ะฒะพ ัะฝะต (ะะะจะะะะะะขะฌะกะฏ ะ ะฟัะตะดะป)
rus_verbs:ะะะกะขะะะะขะฌ{}, // ัะฐะฝะตะฝัะน ะทะฐััะพะฝะฐะป ะฒะพ ัะฝะต (ะะะกะขะะะะขะฌ ะ ะฟัะตะดะป)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะะะะะะขะซะ{}, // ะฒะพ ะฒัะตะผ ะฒะธะฝะพะฒะฐัะพ ะฒะธะฝะพ (ะะะะะะะขะซะ ะ)
rus_verbs:ะะกะขะะะะฏะขะฌ{}, // ะกะจะ ะพััะฐะฒะปััั ะฒ ัะฐะนะพะฝะต ะะตััะธะดัะบะพะณะพ ะทะฐะปะธะฒะฐ ัะพะปัะบะพ ะพะดะธะฝ ะฐะฒะธะฐะฝะพัะตั (ะะกะขะะะะฏะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะะขะะะะซะะะขะฌะกะฏ{}, // ะ ะ ะพััะธะธ ะพัะบะฐะทัะฒะฐัััั ะพั ะฟะปะฐะฝะพะฒ ะฐะฒะธะฐะณััะฟะฟั ะฒ ะัะบัะธะบะต (ะะขะะะะซะะะขะฌะกะฏ ะ ะฟัะตะดะป)
rus_verbs:ะะะะะะะะ ะะะะขะฌ{}, // ะ ะะฐะฑะฐัะดะธะฝะพ-ะะฐะปะบะฐัะธะธ ะปะธะบะฒะธะดะธัะพะฒะฐะฝ ะฟะพะดะฟะพะปัะฝัะน ะทะฐะฒะพะด ะฟะพ ะฟะตัะตัะฐะฑะพัะบะต ะฝะตััะธ (ะะะะะะะะ ะะะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะ ะะะะะะะงะะขะฌ{}, // ะ ะกะจะ ัะฐะทะพะฑะปะฐัะธะปะธ ะบััะฟะฝะตะนััั ะผะฐั
ะธะฝะฐัะธั ั ะบัะตะดะธัะบะฐะผะธ (ะ ะะะะะะะงะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะกะฅะะะขะะขะฌ{}, // ะธั
ัั
ะฒะฐัะธะปะธ ะฒะพ ัะฝะต (ะกะฅะะะขะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะะะงะะขะฌ{}, // ะ ะะตะปะณะพัะพะดะต ะฝะฐัะฐะปะธ ัะฑะพั ะฟะพะดะฟะธัะตะน ะทะฐ ะพัััะฐะฒะบั ะผััะฐ (ะะะงะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะ ะะกะขะ{}, // Cะฐะผะฐั ะผะฐะปะตะฝัะบะฐั ะผัั
ะฐ ัะฐัััั ะฒ ะณะพะปะพะฒะต ะผััะฐะฒัั (ะ ะะกะขะ ะ ะฟัะตะดะป)
rus_verbs:ะฟะพั
ะธัะธัั{}, // ะะฒะพะต ัะพััะธัะฝ, ะฟะพั
ะธัะตะฝะฝัั
ัะตััะพัะธััะฐะผะธ ะฒ ะกะธัะธะธ, ะพัะฒะพะฑะพะถะดะตะฝั (ะฟะพั
ะธัะธัั ะฒ ะฟัะตะดะป)
rus_verbs:ะฃะงะะกะขะะะะะขะฌ{}, // ะฑัะปะธ ะทะฐัััะตะปะตะฝั ะดะฒะฐ ะธัะฟะฐะฝัะบะธั
ะณัะฐะถะดะฐะฝัะบะธั
ะณะฒะฐัะดะตะนัะฐ , ััะฐััะฒะพะฒะฐะฒัะธั
ะฒ ัะปะตะถะบะต (ะฃะงะะกะขะะะะะขะฌ ะ)
rus_verbs:ะฃะกะซะะะะะขะฌ{}, // ะะผะตัะธะบะฐะฝัั ะทะฐะฑะธัะฐัั ัััะฝะพะฒะปะตะฝะฝัั
ะฒ ะ ะพััะธะธ ะดะตัะตะน (ะฃะกะซะะะะะขะฌ ะ)
rus_verbs:ะะ ะะะะะะกะขะ{}, // ะฒั ะฝะต ัะฒะธะดะธัะต ะผััะพ ะธะปะธ ะผะพะปะพะบะพ , ะฟัะพะธะทะฒะตะดะตะฝะฝะพะต ะฒ ัะฐะนะพะฝะต (ะะ ะะะะะะกะขะ ะ ะฟัะตะดะป)
rus_verbs:ะะ ะะะะขะะ ะะะะขะฌะกะฏ{}, // ะฟัะธะทะฒะฐะฝ ะฟะพะผะพัั ะณะพััะปัะถะฐัะตะผั ะฟัะฐะฒะธะปัะฝะพ ะพัะธะตะฝัะธัะพะฒะฐัััั ะฒ ัะปะพะถะฝัั
ะฝัะฐะฒััะฒะตะฝะฝัั
ะบะพะปะปะธะทะธัั
(ะะ ะะะะขะะ ะะะะขะฌะกะฏ ะ)
rus_verbs:ะะะะ ะะะะขะฌ{}, // ะ ะทะฐะปะต ะธะณัะพะฒัั
ะฐะฒัะพะผะฐัะพะฒ ะฟะพะฒัะตะถะดะตะฝั ััะตะฝั ะธ ะฟะพัะพะปะพะบ (ะะะะ ะะะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะะะชะฏะขะฌ{}, // ะ ะฝะฐััะพััะตะต ะฒัะตะผั ะฒ ะดะตััะบะพะผ ัััะตะถะดะตะฝะธะธ ะธะทัััั ัััะพัะฝัะต ะฟัะพะฑั ะฟะธัะธ (ะะะชะฏะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะกะะะะ ะะะขะฌะกะฏ{}, // ะพััะถะดะตะฝะฝัั
, ัะพะดะตัะถะฐัะธั
ัั ะฒ ะฟะพะผะตัะตะฝะธัั
ัััะฐัะฝะพะณะพ ะธะทะพะปััะพัะฐ (ะกะะะะ ะะะขะฌะกะฏ ะ)
rus_verbs:ะะขะงะะกะะะขะฌ{}, // ะฑัะป ะพััะธัะปะตะฝ ะทะฐ ะฝะตััะฟะตะฒะฐะตะผะพััั ะฒ 2007 ะณะพะดั (ะะขะงะะกะะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะฟัะพั
ะพะดะธัั{}, // ะฝะฐั
ะพะดะธะปัั ะฝะฐ ัะฐะฝะบัะธะพะฝะธัะพะฒะฐะฝะฝะพะผ ะผะธัะธะฝะณะต , ะฟัะพั
ะพะดะธะฒัะตะผ ะฒ ัะฐะผะบะฐั
ะฟัะฐะทะดะฝะพะฒะฐะฝะธั ะะฝั ะฝะฐัะพะดะฝะพะณะพ ะตะดะธะฝััะฒะฐ (ะฟัะพั
ะพะดะธัั ะฒ ะฟัะตะดะป)
rus_verbs:ะะะะฃะะซะะะขะฌ{}, // ัะตะนัะฐั ะฒ ะฟัะฐะฒะธัะตะปัััะฒะต ะัะธะฐะผัััั ะฟะพะดัะผัะฒะฐัั ะพ ัะพะทะดะฐะฝะธะธ ัะฟะตัะธะฐะปัะฝะพะณะพ ะฟัะฝะบัะฐ ะฟะพะผะพัะธ ัััะธััะฐะผ (ะะะะฃะะซะะะขะฌ ะ)
rus_verbs:ะะขะ ะะะะ ะขะะะซะะะขะฌ{}, // ะณะปะฐะฒั ััะฑัะตะบัะพะฒ ะฝะต ะฟัะพััะพ ะพััะฐะฟะพััะพะฒัะฒะฐะปะธ ะฒ ะะพัะบะฒะต (ะะขะ ะะะะ ะขะะะซะะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะะะกะขะะกะฌ{}, // ะฒ ะณะพัะพะดะต ะฒะตะดัััั ัะฐะฑะพัั ะฟะพ ัััะฐะฝะพะฒะบะต ะฟัะฐะทะดะฝะธัะฝะพะน ะธะปะปัะผะธะฝะฐัะธะธ (ะะะกะขะะกะฌ ะ)
rus_verbs:ะะะะะ ะะขะฌ{}, // ะะดะพะฑัะตะฝะฝัะผ ะฒ ะฟะตัะฒะพะผ ััะตะฝะธะธ ะทะฐะบะพะฝะพะฟัะพะตะบัะพะผ (ะะะะะ ะะขะฌ ะ)
rus_verbs:ะะะะซะะะขะฌะกะฏ{}, // ะตะผั ะปะตะณัะต ะธัะฟัะฐะฒะปััั , ัะพ , ััะพ ะทะฐะผัะปะธะปะพัั ะฒ ะณะปะฐะทะฐั
ะฟัะตะดัะดััะตะณะพ ััะบะพะฒะพะดััะฒะฐ (ะะะะซะะะขะฌะกะฏ ะ)
rus_verbs:ะะะขะะ ะะะะะะขะฌะกะฏ{}, // ะฟะพัะพะผ ะธะผะตัั ะฟัะฐะฒะพ ะฐะฒัะพัะธะทะพะฒะฐัััั ะฒ ัะธััะตะผะต ะะตะถะดัะฝะฐัะพะดะฝะพะณะพ ะฑะฐะบะฐะปะฐะฒัะธะฐัะฐ (ะะะขะะ ะะะะะะขะฌะกะฏ ะ)
rus_verbs:ะะะฃะกะขะะขะฌะกะฏ{}, // ะ ะพััะธั ะพะฟัััะธะปะฐัั ะฒ ัะฟะธัะบะต ะฝะฐ ัะตััั ะฟะพะทะธัะธะน (ะะะฃะกะขะะขะฌะกะฏ ะ ะฟัะตะดะป)
rus_verbs:ะกะะะ ะะขะฌ{}, // ะกะพะฒะปะฐะดะตะปะตั ัะณะพัะตะฒัะตะณะพ ะฒ ะัะฐะทะธะปะธะธ ะฝะพัะฝะพะณะพ ะบะปัะฑะฐ ัะดะฐะปัั ะฟะพะปะธัะธะธ (ะกะะะ ะะขะฌ ะ)
ัะฐััะธัะฐ:ะฝะตั{}, // ะ ััะพะผ ะฝะตั ัะพะผะฝะตะฝะธั.
ัะฐััะธัะฐ:ะฝะตัั{}, // ะ ััะพะผ ะฝะตัั ัะพะผะฝะตะฝะธั.
rus_verbs:ะฟะพะดะถะตัั{}, // ะะพะดะถะตะณัะธะน ัะตะฑั ะฒ ะะพัะบะฒะต ะผัะถัะธะฝะฐ ะพะบะฐะทะฐะปัั ะฒะตัะตัะฐะฝะพะผ-ะฐัะณะฐะฝัะตะผ
rus_verbs:ะฒะฒะตััะธ{}, // ะ ะะพะปะดะฐะฒะธะธ ะฒะฒะตะดะตะฝ ะทะฐะฟัะตั ะฝะฐ ะฐะผะฝะธััะธั ะธะปะธ ะฟะพะผะธะปะพะฒะฐะฝะธะต ะฟะตะดะพัะธะปะพะฒ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะะกะขะฃะะะซะ{}, // ะะฐะธะฑะพะปะตะต ะธะฝัะตัะตัะฝัะต ัะฐะฑะปะธัะบะธ ะดะพัััะฟะฝั ะฒ ะพัะฝะพะฒะฝะพะน ัะบัะฟะพะทะธัะธะธ ะผัะทะตั (ะะะกะขะฃะะะซะ ะ)
rus_verbs:ะะะะะกะะฃะขะฌ{}, // ะฒะพะฟัะพั ะฟะพะฒะธั ะฒ ะผะณะปะธััะพะผ ะดะตะผะพะบัะฐัะธัะตัะบะพะผ ะฒะพะทะดัั
ะต (ะะะะะกะะฃะขะฌ ะ)
rus_verbs:ะะะะ ะะะขะฌ{}, // ะ ะัะฐะบะต ัะผะตััะฝะธะบ ะฒะทะพัะฒะฐะป ะฒ ะผะตัะตัะธ ะณััะฟะฟั ัััะบะผะตะฝะพะฒ (ะะะะ ะะะขะฌ ะ)
rus_verbs:ะะขะะฏะขะฌ{}, // ะ ะคะธะฝะปัะฝะดะธะธ ั ัะพััะธัะฝะบะธ, ะฟัะธะฑัะฒัะตะน ะฟะพ ัััะธััะธัะตัะบะพะน ะฒะธะทะต, ะพัะฝัะปะธ ะดะตัะตะน (ะะขะะฏะขะฌ ะ)
rus_verbs:ะะะะขะ{}, // ะฏ ะฝะตะดะฐะฒะฝะพ ะฟะพัะตัะธะป ะฒัะฐัะฐ ะธ ั ะผะตะฝั ะฒ ะณะปะฐะทะฐั
ะฝะฐัะปะธ ะบะฐะบัั-ัะพ ัะธะณะฝั (ะะะะขะ ะ ะฟัะตะดะป)
rus_verbs:ะะะกะขะ ะะะะขะฌะกะฏ{}, // ะะตะฒััะบะฐ, ะทะฐัััะตะปะธะฒัะฐััั ะฒ ัะตะฝััะต ะะธะตะฒะฐ, ะฑัะปะฐ ะทะฐะผะตัะฐะฝะฐ ะฒ ัะบะฐะฝะดะฐะปะต ั ะฒะปะธััะตะปัะฝัะผะธ ะปัะดัะผะธ (ะะะกะขะ ะะะะขะฌะกะฏ ะ)
rus_verbs:ััะฐััะพะฒะฐัั{}, // ะ ะกััะฐัะฑััะณะต ัะตะณะพะดะฝั ััะฐัััะตั ะทะธะผะฝัั ัะตััะธั ะะฐัะปะฐะผะตะฝััะบะพะน ะฐััะฐะผะฑะปะตะธ ะกะพะฒะตัะฐ ะะฒัะพะฟั (ััะฐััะพะฒะฐัั ะฒ)
rus_verbs:ะะะะะะะซะะะขะฌะกะฏ{}, // ะัะฝะพัะตะฝะธะต ะบ ะดะตะฝัะณะฐะผ ะทะฐะบะปะฐะดัะฒะฐะตััั ะฒ ะดะตัััะฒะต (ะะะะะะะซะะะขะฌะกะฏ ะ)
rus_verbs:ะะะะะะะขะฌะกะฏ{}, // ะะตะฟััะฐัะฐะผ ะฟะพะผะตัะฐัั ะฝะฐะฟะธะฒะฐัััั ะฒ ะทะดะฐะฝะธะธ ะะพัะดัะผั (ะะะะะะะขะฌะกะฏ ะ)
rus_verbs:ะะซะะ ะะะะขะฌะกะฏ{}, // ะัะตะถะดะต ะฒัะตะณะพ ะฑัะปะพ ะทะฐัะฒะปะตะฝะพ, ััะพ ะผะธัะพะฒะฐั ัะบะพะฝะพะผะธะบะฐ ะบะฐะบะธะผ-ัะพ ะพะฑัะฐะทะพะผ ัะฐะผะฐ ะฒัะฟัะฐะฒะธััั ะฒ ะฟัะพัะตััะต ะฑะธะทะฝะตั-ัะธะบะปะฐ (ะะซะะ ะะะะขะฌะกะฏ ะ)
rus_verbs:ะฏะะะฏะขะฌะกะฏ{}, // ะพะฝะฐ ัะฒะปัะปะฐัั ะบะพ ะผะฝะต ะฒะพ ะฒัะตั
ะผะพะธั
ัะฝะฐั
(ะฏะะะฏะขะฌะกะฏ ะ)
rus_verbs:ะกะขะะะะ ะะะะขะฌะกะฏ{}, // ัะตะนัะฐั ั ััะฐะถะธััััั ะฒ ะพะดะฝะพะน ะบะพะผะฟะฐะฝะธะธ (ะกะขะะะะ ะะะะขะฌะกะฏ ะ)
rus_verbs:ะะะกะขะ ะะะฏะขะฌ{}, // ะฃัะพะถะตะฝัั ะงะตัะฝะธ, ะพะฑัััะตะปัะฒัะธะต ะฟะพะปะธัะตะนัะบะธั
ะฒ ัะตะฝััะต ะะพัะบะฒั, ะฐัะตััะพะฒะฐะฝั (ะะะกะขะ ะะะฏะขะฌ ะ)
rus_verbs:ะ ะะกะะ ะะกะขะ ะะะะขะฌ{}, // ะะพัะบะธ โ ัะฐัะฟัะพัััะฐะฝัะฝะฝัะต ะฒ ัะฐััะธัะตะปัะฝะพะผ ะธ ะถะธะฒะพัะฝะพะผ ะผะธัะต ัะปะพะถะฝัะต ััะธัั ะฒัััะธั
ะถะธัะฝัั
ะบะธัะปะพั ะธ ะฒัััะธั
ะฒััะพะบะพะผะพะปะตะบัะปััะฝัั
ัะฟะธััะพะฒ (ะ ะะกะะ ะะกะขะ ะะะะขะฌ ะ)
rus_verbs:ะะ ะะะะกะขะ{}, // ะกัะฐะฒะฝะธัะตะปัะฝะฐั ััะณะฐัะฝะพััั ะฝะตะบะพัะพััั
ะฒะทััะฒัะฐััั
ะฒะตัะตััะฒ ะฟัะธะฒะตะดะตะฝะฐ ะฒ ัะปะตะดัััะตะน ัะฐะฑะปะธัะต (ะะ ะะะะกะขะ ะ)
rus_verbs:ะะะะะะะะ ะะขะฌ{}, // ะงะธะฝะพะฒะฝะธะบะพะฒ ะะธะฝะบัะปััััั ะทะฐะฟะพะดะพะทัะธะปะธ ะฒ ะฐัะตัะต ั ะทะฐะฟะพะฒะตะดะฝัะผะธ ะทะตะผะปัะผะธ (ะะะะะะะะ ะะขะฌ ะ)
rus_verbs:ะะะกะขะฃะะะขะฌ{}, // ะ ะัะตะฝะปะฐะฝะดะธะธ ััะฐะปะธ ะฝะฐัััะฟะฐัั ะปะตะดะฝะธะบะธ (ะะะกะขะฃะะะขะฌ ะ)
rus_verbs:ะะซะะะะฏะขะฌะกะฏ{}, // ะ ะธััะพัะธะธ ะะตะผะปะธ ะฒัะดะตะปััััั ัะปะตะดัััะธะต ะปะตะดะฝะธะบะพะฒัะต ััั (ะะซะะะะฏะขะฌะกะฏ ะ)
rus_verbs:ะะ ะะะกะขะะะะขะฌ{}, // ะะฐะฝะฝัะต ะฟัะตะดััะฐะฒะปะตะฝั ะฒ ั
ัะพะฝะพะปะพะณะธัะตัะบะพะผ ะฟะพััะดะบะต (ะะ ะะะกะขะะะะขะฌ ะ)
rus_verbs:ะะะ ะฃะจะะขะฌะกะฏ{}, // ะ ะกะตะฒะตัะฝะพะน ะัะตัะธะธ ะฝะฐ ะฒะพะธะฝัะบัั ัะฐััั ะพะฑัััะธะปะฐัั ัะฝะตะถะฝะฐั ะปะฐะฒะธะฝะฐ (ะะะ ะฃะจะะขะฌะกะฏ ะ, ะะ)
rus_verbs:ะะะะะะะขะฌ{}, // ะะพัะพะฒัะต ะบะพะผะฟะพัั ะฟะพะดะฐัั ะฒ ััะพะปะพะฒัั
ะธ ะบะฐัะต (ะะะะะะะขะฌ ะ)
rus_verbs:ะะะขะะะะขะฌ{}, // ะกะตะณะพะดะฝั ะบะพะผะฟะพั ะณะพัะพะฒัั ะฒ ะดะพะผะฐัะฝะธั
ััะปะพะฒะธัั
ะธะท ััั
ะพัััะบัะพะฒ ะธะปะธ ะทะฐะผะพัะพะถะตะฝะฝัั
ัััะบัะพะฒ ะธ ัะณะพะด (ะะะขะะะะขะฌ ะ)
rus_verbs:ะะะะะะะซะะะขะฌะกะฏ{}, // ะฒ ะฝะฐััะพััะตะต ะฒัะตะผั ะพะฝ ะฟะพะฒัะตะผะตััะฝะพ ะฒะพะทะดะตะปัะฒะฐะตััั ะฒ ะพะณะพัะพะดะฐั
(ะะะะะะะซะะะขะฌะกะฏ ะ)
rus_verbs:ะ ะะกะะะะะซะะะขะฌ{}, // ะกะพะทัะตะฒัะธะต ัะตะผะตะฝะฝัะต ัะบะทะตะผะฟะปััั ัะฐัะบะปะฐะดัะฒะฐัั ะฝะฐ ัะพะปะฝัะต ะธะปะธ ะฒ ัะตะฟะปะพะผ ะผะตััะต, ะณะดะต ะพะฝะธ ะดะตะปะฐัััั ะผัะณะบะธะผะธ (ะ ะะกะะะะะซะะะขะฌะกะฏ ะ, ะะ)
rus_verbs:ะ ะะกะะะะะซะะะขะฌะกะฏ{},
rus_verbs:ะกะะะะ ะะขะฌะกะฏ{}, // ะะฑัะบะฝะพะฒะตะฝะฝะพ ะพะณัััั ัะพะฑะธัะฐัััั ะฒ ะฟะพะปััะฟะตะปะพะผ ัะพััะพัะฝะธะธ (ะกะะะะ ะะขะฌะกะฏ ะ)
rus_verbs:ะะ ะะะ ะะะะขะฌ{}, // ะ ัะพัะณะพะฒะพะผ ัะตะฝััะต ะะถะตะฒัะบะฐ ะฟัะพะณัะตะผะตะป ะฒะทััะฒ (ะะ ะะะ ะะะะขะฌ ะ)
rus_verbs:ะกะะฏะขะฌ{}, // ััะพะฑั ัะฝััั ะธั
ะฒะพ ะฒัะตะน ะบัะฐัะพัะต. (ะกะะฏะขะฌ ะ)
rus_verbs:ะฏะะะขะฌะกะฏ{}, // ะพะฝะฐ ัะฒะธะปะฐัั ะบ ะฝะตะผั ะฒะพ ัะฝะต. (ะฏะะะขะฌะกะฏ ะ)
rus_verbs:ะะะ ะะขะฌ{}, // ะผั ะถะต ะฒะพ ะฒัะตะผ ะฒะตัะธะปะธ ะบะฐะฟะธัะฐะฝั. (ะะะ ะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะฒัะดะตัะถะฐัั{}, // ะะณัะฐ ะฒัะดะตัะถะฐะฝะฐ ะฒ ะฝะฐััะฝะพ-ัะฐะฝัะฐััะธัะตัะบะพะผ ััะธะปะต. (ะะซะะะ ะะะะะซะ ะ)
rus_verbs:ะะ ะะะะะะะขะฌ{}, // ะผั ะฟััะฐะปะธัั ะฟัะตะพะดะพะปะตัั ะตะต ะฒะพ ะผะฝะพะณะธั
ะผะตััะฐั
. (ะะ ะะะะะะะขะฌ ะ)
ะธะฝัะธะฝะธัะธะฒ:ะะะะะกะะขะฌ{ aux stress="ะฝะฐะฟะธั^ะฐัั" }, // ะัะพะณัะฐะผะผะฐ, ะฝะฐะฟะธัะฐะฝะฝะฐั ะฒ ัะฟะตัะบะต, ะฒัะฟะพะปะฝะธะปะฐ ะฝะตะดะพะฟัััะธะผัั ะพะฟะตัะฐัะธั. (ะะะะะกะะขะฌ ะ)
ะณะปะฐะณะพะป:ะะะะะกะะขะฌ{ aux stress="ะฝะฐะฟะธั^ะฐัั" },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะะะะกะะะะซะ{},
rus_verbs:ะะกะขะฌ{}, // ัั ะดะฐะถะต ะฒะพ ัะฝะต ะตะป. (ะะกะขะฌ/ะบััะฐัั ะ)
rus_verbs:ะฃะกะะกะขะฌะกะฏ{}, // ะะฝ ัะดะพะฑะฝะพ ััะตะปัั ะฒ ะบัะตัะปะต. (ะฃะกะะกะขะฌะกะฏ ะ)
rus_verbs:ะขะะ ะะะะะขะฌ{}, // ะะฝ ัะพัะณัะตั ะฒ ะฟะฐะปะฐัะบะต. (ะขะะ ะะะะะขะฌ ะ)
rus_verbs:ะกะะะะะกะขะะขะฌ{}, // ะะฝ ัะพะฒะผะตััะธะป ะฒ ัะตะฑะต ะฟะธัะฐัะตะปั ะธ ั
ัะดะพะถะฝะธะบะฐ. (ะกะะะะะกะขะะขะฌ ะ)
rus_verbs:ะะะะซะะะขะฌ{}, // ะพะฑ ััะพะผ ะฝะตะปัะทั ะทะฐะฑัะฒะฐัั ะดะฐะถะต ะฒะพ ัะฝะต. (ะะะะซะะะขะฌ ะ)
rus_verbs:ะฟะพะณะพะฒะพัะธัั{}, // ะะฐะฒะฐะนัะต ะฟะพะณะพะฒะพัะธะผ ะพะฑ ััะพะผ ะฒ ะฟัะธัััััะฒะธะธ ะฐะดะฒะพะบะฐัะฐ
rus_verbs:ัะฑัะฐัั{}, // ะ ะฒะฐะณะพะฝะฐั
ะผะตััะพ ะดะปั ะบะพะผัะพััะฐ ะฟะฐััะฐะถะธัะพะฒ ัะฑะตััั ัะธะดะตะฝัั (ะฃะะ ะะขะฌ ะ, ะะะฏ)
rus_verbs:ัะฟะฐััั{}, // ะ ะขะฐะธะปะฐะฝะดะต ะฝะฐ ะฐะฒัะพะฑัั ั ัะพััะธะนัะบะธะผะธ ัััะธััะฐะผะธ ัะฟะฐะป ะฑะฐัะตะฝะฝัะน ะบัะฐะฝ (ะฃะะะกะขะฌ ะ, ะะ)
rus_verbs:ัะฐัะบัััั{}, // ะ ะ ะพััะธะธ ัะฐัะบััะปะธ ะบััะฟะฝะตะนััั ะฒ ัััะฐะฝะต ัะตัั ัะฐะปััะธะฒะพะผะพะฝะตััะธะบะพะฒ (ะ ะะกะะ ะซะขะฌ ะ)
rus_verbs:ัะพะตะดะธะฝะธัั{}, // ัะพะตะดะธะฝะธัั ะฒ ัะตะฑะต (ะกะะะะะะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะธะทะฑัะฐัั{}, // ะ ะฎะถะฝะพะน ะะพัะตะต ะธะทะฑัะฐะฝ ะฝะพะฒัะน ะฟัะตะทะธะดะตะฝั (ะะะะ ะะขะฌ ะ ะฟัะตะดะป)
rus_verbs:ะฟัะพะฒะพะดะธัััั{}, // ะะฑััะบะธ ะฟัะพะฒะพะดัััั ะฒ ะฒะพัะพะฝะตะถัะบะพะผ ะะพะผะต ะฟัะฐะฒ ัะตะปะพะฒะตะบะฐ (ะะ ะะะะะะขะฌะกะฏ ะ)
ะฑะตะทะปะธั_ะณะปะฐะณะพะป:ั
ะฒะฐัะฐะตั{}, // ะ ััะพะน ััะฐััะต ะฝะต ั
ะฒะฐัะฐะตั ัััะปะพะบ ะฝะฐ ะธััะพัะฝะธะบะธ ะธะฝัะพัะผะฐัะธะธ. (ะะะะะะง ั
ะฒะฐัะฐัั ะฒ)
rus_verbs:ะฝะฐะฝะพัะธัั{}, // ะ ะฑะปะธะถะฝะตะผ ะฑะพั ะฝะฐะฝะพัะธั ะผะพัะฝัะต ัะดะฐัั ัะฒะพะธะผ ะบะพััะปัะฒัะผ ะบัะปะฐะบะพะผ. (ะะะะะกะะขะฌ ะ + ะฟัะตะดะป.)
rus_verbs:ัะฐััะตะฟะปััััั{}, // ะกะฐั
ะฐัะพะทะฐ ะถะต ะฑััััะพ ัะฐััะตะฟะปัะตััั ะฒ ะฟะธัะตะฒะฐัะธัะตะปัะฝะพะผ ััะฐะบัะต ะฝะฐ ะณะปัะบะพะทั ะธ ัััะบัะพะทั (ะ ะะกะฉะะะะฏะขะฌะกะฏ ะ, ะะ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะธะทะฒะตััะฝัะน{}, // ะ ะะฒัะพะฟะต ัะฐั
ะฐั ะฑัะป ะธะทะฒะตััะตะฝ ะตัั ัะธะผะปัะฝะฐะผ. (ะะะะะกะขะะซะ ะ)
rus_verbs:ะฒััะฐะฑะพัะฐัั{}, // ะกะฟะพัะพะฑั, ะฒััะฐะฑะพัะฐะฝะฝัะต ะฒะพ ะคัะฐะฝัะธะธ, ะฟะตัะตัะปะธ ะทะฐัะตะผ ะฒ ะะตัะผะฐะฝะธั ะธ ะดััะณะธะต ัััะฐะฝั ะะฒัะพะฟั. (ะะซะ ะะะะขะะขะฌ ะ)
rus_verbs:ะะฃะะฌะขะะะะ ะะะะขะฌะกะฏ{}, // ะัะปััะธะฒะธััะตััั ะฒ ัะตะณะธะพะฝะฐั
ั ัะผะตัะตะฝะฝัะผ ะบะปะธะผะฐัะพะผ ั ัะผะตัะตะฝะฝัะผ ะบะพะปะธัะตััะฒะพะผ ะพัะฐะดะบะพะฒ ะธ ััะตะฑัะตั ะฟะปะพะดะพัะพะดะฝะพะน ะฟะพัะฒั. (ะะฃะะฌะขะะะะ ะะะะขะฌะกะฏ ะ)
rus_verbs:ัะฐััั{}, // ะผะฐะผะฐ ะดััะธ ะฝะต ัะฐัะปะฐ ะฒ ัะฒะพะธั
ะดะตััั
(ะงะะฏะขะฌ ะ)
rus_verbs:ัะปัะฑะฐัััั{}, // ะะฐะดะธะผ ัะปัะฑะฐะปัั ะฒะพ ัะฝะต. (ะฃะะซะะะขะฌะกะฏ ะ)
rus_verbs:ัะฐััะตัััััั{}, // ะัะธะตะทะถะธะต ัะฐััะตััะปะธัั ะฒ ะฑะตัะพะฝะฝะพะผ ะปะฐะฑะธัะธะฝัะต ัะปะธั (ะ ะะกะขะะ ะฏะขะฌะกะฏ ะ)
rus_verbs:ะฒััั{}, // ะฒัะปะธ ะฒะพะปะบะธ ะณะดะต-ัะพ ะฒ ะปะตัั (ะะซะขะฌ ะ)
rus_verbs:ะะะะะ ะะขะฌ{}, // ะฒััััะฟะฐะฒัะธะน ะทะฐะฒะตัะธะป ะฝะฐั ะฒ ะฝะฐะผะตัะตะฝะธะธ ะฒัะฟะพะปะฝะธัั ะพะฑะตัะฐะฝะธะต (ะะะะะ ะะขะฌ ะ)
rus_verbs:ะะกะงะะะะฃะขะฌ{}, // ะทะฒะตัะธ ะธััะตะทะปะธ ะฒะพ ะผัะฐะบะต. (ะะกะงะะะะฃะขะฌ ะ)
rus_verbs:ะะกะขะะขะฌ{}, // ะฒััะฐัั ะฒะพ ะณะปะฐะฒะต ัะตะปะพะฒะตัะตััะฒะฐ. (ะะกะขะะขะฌ ะ)
rus_verbs:ะฃะะะขะ ะะะะฏะขะฌ{}, // ะ ะขะธะฑะตัะต ัะฟะพััะตะฑะปััั ะบะธัะฟะธัะฝัะน ะทะตะปัะฝัะน ัะฐะน. (ะฃะะะขะ ะะะะฏะขะฌ ะ)
rus_verbs:ะะะะะะะขะฌะกะฏ{}, // ะะฐะฟะธัะพะบ ะพั
ะปะฐะถะดะฐะตััั ะธ ะฟะพะดะฐัััั ะฒ ั
ะพะปะพะดะฝะพะผ ะฒะธะดะต. (ะะะะะะะขะฌะกะฏ ะ)
rus_verbs:ะะกะะะะฌะะะะะขะฌะกะฏ{}, // ะฒ ะธะณัะต ะธัะฟะพะปัะทััััั ัะตะบััััั ะฑะพะปััะตะณะพ ัะฐะทัะตัะตะฝะธั (ะะกะะะะฌะะะะะขะฌะกะฏ ะ)
rus_verbs:ะพะฑััะฒะธัั{}, // ะ ะณะฐะทะตัะต ะพะฑััะฒะธะปะธ ะพ ะบะพะฝะบัััะต.
rus_verbs:ะะกะะซะฅะะฃะขะฌ{}, // ะฒะพ ะผะฝะต ะฒัะฟัั
ะฝัะป ะณะฝะตะฒ. (ะะกะะซะฅะะฃะขะฌ ะ)
rus_verbs:ะะ ะซะขะฌะกะฏ{}, // ะ ะตะณะพ ัะปะพะฒะฐั
ะบัะพะตััั ัะณัะพะทะฐ. (ะะ ะซะขะฌะกะฏ ะ)
rus_verbs:ะฟะพะดะฝััััั{}, // ะ ะบะปะฐััะต ะฒะดััะณ ะฟะพะดะฝัะปัั ััะผ. (ะฟะพะดะฝััััั ะฒ)
rus_verbs:ะฝะฐัััะฟะธัั{}, // ะ ะบะปะฐััะต ะฝะฐัััะฟะธะปะฐ ะฟะพะปะฝะฐั ัะธัะธะฝะฐ. (ะฝะฐัััะฟะธัั ะฒ)
rus_verbs:ะบะธะฟะตัั{}, // ะ ะฝัะผ ะบะธะฟะธั ะทะปะพะฑะฐ. (ะบะธะฟะตัั ะฒ)
rus_verbs:ัะพะตะดะธะฝะธัััั{}, // ะ ะฝัะผ ัะพะตะดะธะฝะธะปะธัั ั
ัะฐะฑัะพััั ะธ ะฒะตะปะธะบะพะดััะธะต. (ัะพะตะดะธะฝะธัััั ะฒ)
ะธะฝัะธะฝะธัะธะฒ:ะะะ ะะขะฌ{ aux stress="ะฟะฐั^ะธัั"}, // ะััะพะบะพ ะฒ ะฝะตะฑะต ะฟะฐัะธั ะพััะป, ะฟะปะฐะฒะฝะพ ะพะฟะธััะฒะฐั ะบััะณะธ. (ะะะ ะะขะฌ ะ)
ะณะปะฐะณะพะป:ะะะ ะะขะฌ{ aux stress="ะฟะฐั^ะธัั"},
ะดะตะตะฟัะธัะฐััะธะต:ะฟะฐัั{ aux stress="ะฟะฐั^ั" },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะะ ะฏะฉะะ{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะะ ะะะจะะ{},
rus_verbs:ะกะะฏะขะฌ{}, // ะะปะฐะฒั ัะพะฑะพัะฐ ัะธัะปะธ ะฒ ะปััะฐั
ัะพะปะฝัะฐ. (ะกะะฏะขะฌ ะ)
rus_verbs:ะ ะะกะะะะะะะขะฌ{}, // ะะพััะธะฝะธัะฐ ัะฐัะฟะพะปะพะถะตะฝะฐ ะณะปัะฑะพะบะพ ะฒ ะณะพัะฐั
. (ะ ะะกะะะะะะะขะฌ ะ)
rus_verbs:ัะฐะทะฒะธะฒะฐัััั{}, // ะะตะนััะฒะธะต ะฒ ะบะพะผะตะดะธะธ ัะฐะทะฒะธะฒะฐะตััั ะฒ ะดะฒัั
ะฟะปะฐะฝะฐั
. (ัะฐะทะฒะธะฒะฐัััั ะฒ)
rus_verbs:ะะะกะะะะขะฌ{}, // ะะตัะธ ะฟะพัะฐะดะธะปะธ ั ะฝะฐั ะฒะพ ะดะฒะพัะต ัะฒะตัั. (ะะะกะะะะขะฌ ะ)
rus_verbs:ะะกะะะ ะะะฏะขะฌ{}, // ะััะฝัะต ะฟัะธะฒััะบะธ ัะปะตะดัะตั ะธัะบะพัะตะฝััั ะฒ ัะฐะผะพะผ ะฝะฐัะฐะปะต. (ะะกะะะ ะะะฏะขะฌ ะ)
rus_verbs:ะะะกะกะขะะะะะะขะฌ{}, // ะะณะพ ะฒะพัััะฐะฝะพะฒะธะปะธ ะฒ ะฟัะฐะฒะฐั
. (ะะะกะกะขะะะะะะขะฌ ะ)
rus_verbs:ะะะะะะะขะฌะกะฏ{}, // ะผั ะฟะพะปะฐะณะฐะตะผัั ะฝะฐ ะฝะตะณะพ ะฒ ััะธั
ะฒะพะฟัะพัะฐั
(ะะะะะะะขะฌะกะฏ ะ)
rus_verbs:ะฃะะะ ะะขะฌ{}, // ะพะฝะธ ัะผะธัะฐะปะธ ะฒะพ ัะฝะต. (ะฃะะะ ะะขะฌ ะ)
rus_verbs:ะะ ะะะะะะขะฌ{}, // ะะฝะฐ ัะธะปัะฝะพ ะฟัะธะฑะฐะฒะธะปะฐ ะฒ ะฒะตัะต. (ะะ ะะะะะะขะฌ ะ)
rus_verbs:ะฟะพัะผะพััะตัั{}, // ะะพัะผะพััะธัะต ะฒ ัะฟะธัะบะต. (ะฟะพัะผะพััะตัั ะฒ)
rus_verbs:ะฟัะพะธะทะฒะพะดะธัััั{}, // ะัะดะฐัะฐ ะฝะพะฒัั
ะฟะฐัะฟะพััะพะฒ ะฑัะดะตั ะฟัะพะธะทะฒะพะดะธัััั ะฒ ัะปะตะดัััะตะผ ะฟะพััะดะบะต (ะฟัะพะธะทะฒะพะดะธัััั ะฒ)
rus_verbs:ะฟัะธะฝััั{}, // ะะพะบัะผะตะฝั ะฟัะธะฝัั ะฒ ัะปะตะดัััะตะน ัะตะดะฐะบัะธะธ (ะฟัะธะฝััั ะฒ)
rus_verbs:ัะฒะตัะบะฝััั{}, // ะผะตั ะตะณะพ ัะฒะตัะบะฝัะป ะฒะพ ััะผะต. (ัะฒะตัะบะฝััั ะฒ)
rus_verbs:ะะซะ ะะะะขะซะะะขะฌ{}, // ัั ะดะพะปะถะตะฝ ะฒััะฐะฑะฐััะฒะฐัั ะฒ ัะตะฑะต ัะธะปั ะฒะพะปะธ (ะะซะ ะะะะขะซะะะขะฌ ะ)
rus_verbs:ะดะพััะฐัั{}, // ะญัะธ ัะฒะตะดะตะฝะธั ะผั ะดะพััะฐะปะธ ะฒ ะะพะปะณะพะณัะฐะดะต. (ะดะพััะฐัั ะฒ)
rus_verbs:ะทะฒััะฐัั{}, // ะฒ ะดะพะผะต ะทะฒััะฐะปะฐ ะผัะทัะบะฐ (ะทะฒััะฐัั ะฒ)
rus_verbs:ะบะพะปะตะฑะฐัััั{}, // ะบะพะปะตะฑะปะตััั ะฒ ะฒัะฑะพัะต (ะบะพะปะตะฑะฐัััั ะฒ)
rus_verbs:ะผะตัะฐัั{}, // ะผะตัะฐัั ะฒ ะบะฐััััะปะต ััะฟ (ะผะตัะฐัั ะฒ)
rus_verbs:ะฝะฐัะฐััะฐัั{}, // ะฒะพ ะผะฝะต ะฝะฐัะฐััะฐะป ะณะฝะตะฒ (ะฝะฐัะฐััะฐัั ะฒ)
rus_verbs:ะพัะฑััั{}, // ะะฐะดะธะผ ะพัะฑัะป ะฒ ะฝะตะธะทะฒะตััะฝะพะผ ะฝะฐะฟัะฐะฒะปะตะฝะธะธ (ะพัะฑััั ะฒ)
rus_verbs:ัะฒะตัะธัััั{}, // ะฒะพ ะฒัะตะผ ะดะพะผะต ัะฒะตัะธะปะพัั ัะพะปัะบะพ ะพะบะฝะพ ะตะต ัะฟะฐะปัะฝะธ. (ัะฒะตัะธัััั ะฒ)
rus_verbs:ะฒััะธััะฒะฐัั{}, // ะฒััะธััะฒะฐัั ะฒ ะบะฝะธะณะต
rus_verbs:ะณัะดะตัั{}, // ะฃ ะฝะตะณะพ ะฒ ััะฐั
ะณัะดะธั.
rus_verbs:ะดะฐะฒะฐัั{}, // ะ ััะพะน ะปะฐะฒะบะต ะดะฐัั ะฒ ะดะพะปะณ?
rus_verbs:ะฟะพะฑะปะตัะบะธะฒะฐัั{}, // ะัะฐัะธะฒะพะต ััะตะบะปััะบะพ ะฟะพะฑะปะตัะบะธะฒะฐะปะพ ะฒ ะฟัะปัะฝะพะน ััะฐะฒะต ั ะดะพัะพะถะบะธ.
rus_verbs:ัะฐะทะพะนัะธัั{}, // ะะฝะธ ัะฐะทะพัะปะธัั ะฒ ัะตะผะฝะพัะต.
rus_verbs:ะฟัะธะฑะตะถะฐัั{}, // ะะฐะปััะธะบ ะฟัะธะฑะตะถะฐะป ะฒ ัะปะตะทะฐั
.
rus_verbs:ะฑะธัััั{}, // ะะฝะฐ ะฑะธะปะฐัั ะฒ ะธััะตัะธะบะต.
rus_verbs:ัะตะณะธัััะธัะพะฒะฐัััั{}, // ัะตะณะธัััะธัะพะฒะฐัััั ะฒ ัะธััะตะผะต
rus_verbs:ััะธัะฐัั{}, // ั ะฑัะดั ััะธัะฐัั ะฒ ัะผะต
rus_verbs:ััะฐั
ะฐัััั{}, // ััะฐั
ะฐัััั ะฒ ะณะฐะผะฐะบะต
rus_verbs:ัะบะพะฝัะตะฝััะธัะพะฒะฐัััั{}, // ัะบะพะฝัะตะฝััะธัะพะฒะฐัััั ะฒ ะพะดะฝะพะน ัะพัะบะต
rus_verbs:ัะฐะทัััะฐัั{}, // ัะฐะทัััะฐัั ะฒ ะดัะพะฑะธะปะบะต
rus_verbs:ะทะฐัะธะดะตัััั{}, // ะทะฐัะธะดะตัััั ะฒ ะณะพัััั
rus_verbs:ะทะฐัะธะถะธะฒะฐัััั{}, // ะทะฐัะธะถะธะฒะฐัััั ะฒ ะณะพัััั
rus_verbs:ััะพะฟะธัั{}, // ััะพะฟะธัั ะปะพะดะบั ะฒ ัะตะบะต (ััะพะฟะธัั ะฒ ัะตะบะต)
rus_verbs:ะฝะฐะฒะตััะธัั{}, // ะฝะฐะฒะตััะธัั ะฒ ะดะพะผะต ะฟัะตััะฐัะตะปัั
rus_verbs:ะทะฐะฟะพะผะฝะธัั{}, // ะทะฐะฟะพะผะฝะธัั ะฒ ะบััะต
rus_verbs:ัะฑะธะฒะฐัั{}, // ัะฑะธะฒะฐัั ะฒ ะฟะพะผะตัะตะฝะธะธ ะฟะพะปะธัะธะธ (-score ัะฑะธะฒะฐัั ะฝะตะพะดัั. ะดะพะผ.)
rus_verbs:ะฑะฐะทะธัะพะฒะฐัััั{}, // ัััะฐะฝะพะฒะบะฐ ะฑะฐะทะธััะตััั ะฒ ัะตััะต ะณะพัะพะดะฐ (ngram ัะตััะฐ ะณะพัะพะดะฐ - ะฟัะพะฒะตัะธัั ััะพ ะตััั ะฟัะพะฒะตัะบะฐ)
rus_verbs:ะฟะพะบัะฟะฐัั{}, // ะงะฐัะต ะฒัะตะณะพ ัะพััะธัะฝะต ะฟะพะบัะฟะฐัั ะฒ ะธะฝัะตัะฝะตัะต ะฑััะพะฒัั ัะตั
ะฝะธะบั.
rus_verbs:ั
ะพะดะธัั{}, // ั
ะพะดะธัั ะฒ ะฟะฐะปััะพ (ัะดะตะปะฐัั ะฅะะะะขะฌ + ะฒ + ะะะะะะ ะฟัะตะดะป.ะฟ.)
rus_verbs:ะทะฐะปะพะถะธัั{}, // ะดะธะฒะตััะฐะฝัั ะทะฐะปะพะถะธะปะธ ะฒ ะฟะพะผะตัะตะฝะธะธ ะฑะพะผะฑั
rus_verbs:ะพะณะปัะดัะฒะฐัััั{}, // ะพะณะปัะดัะฒะฐัััั ะฒ ะทะตัะบะฐะปะต
rus_verbs:ะฝะฐัะธัะพะฒะฐัั{}, // ะฝะฐัะธัะพะฒะฐัั ะฒ ัะตััะฐะดะบะต
rus_verbs:ะฟัะพะฑะธัั{}, // ะฟัะพะฑะธัั ะพัะฒะตัััะฒะธะต ะฒ ััะตะฝะต
rus_verbs:ะฟะพะฒะตััะตัั{}, // ะฟะพะฒะตััะตัั ะฒ ััะบะต
rus_verbs:ะฒะตััะตัั{}, // ะฏ ะฒะตััะตะป ะฒ ััะบะฐั
rus_verbs:ัะฒะฐัััั{}, // ะะตัะตะฒะบะฐ ัะฒะตััั ะฒ ะผะตััะต ะฝะฐะดัะตะทะฐ
rus_verbs:ัะฐัะฟัะพัััะฐะฝััััั{}, // ัะฐัะฟัะพัััะฐะฝััััั ะฒ ััะตะดะต ะฝะฐัะบะพะผะฐะฝะพะฒ
rus_verbs:ะฟะพะฟัะพัะฐัััั{}, // ะฟะพะฟัะพัะฐัััั ะฒ ะทะดะฐะฝะธะธ ะผะพัะณะฐ
rus_verbs:ัะพะพะฑัะฐะถะฐัั{}, // ัะพะพะฑัะฐะถะฐัั ะฒ ัะผะต
ะธะฝัะธะฝะธัะธะฒ:ะฟัะพััะฟะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฟัะพััะฟะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฟัะพััะฟะฐัััั ะฒ ััะถะพะน ะบัะพะฒะฐัะธ
rus_verbs:ะทะฐะตั
ะฐัั{}, // ะะพะปั ะทะฐะตั
ะฐะป ะฒ ะณะพััะธ (ะฒ ะณะพััะธ - ัััะพะนัะธะฒัะน ะฝะฐัะตัะฝัะน ะพะฑะพัะพั)
rus_verbs:ัะฐะทะพะฑัะฐัั{}, // ัะฐะทะพะฑัะฐัั ะฒ ะณะฐัะฐะถะต
rus_verbs:ะฟะพะผะตัะตัั{}, // ะฟะพะผะตัะตัั ะฒ ะฟััะธ
rus_verbs:ัะฐะทะปะธัะธัั{}, // ัะฐะทะปะธัะธัั ะฒ ัะตะผะฝะพัะต
rus_verbs:ัะธัะพะฒะฐัั{}, // ัะธัะพะฒะฐัั ะฒ ะณัะฐัะธัะตัะบะพะผ ัะตะดะฐะบัะพัะต
rus_verbs:ะฟัะพัะปะตะดะธัั{}, // ะฟัะพัะปะตะดะธัั ะฒ ะทะฐะฟะธััั
ะบะฐะผะตั ัะปะตะถะตะฝะธั
rus_verbs:ัะพะฒะตััะฐัััั{}, // ะัะฐะฒะพััะดะธะต ัะพะฒะตััะฐะตััั ะฒ ััะดะต
rus_verbs:ะทะฐะดัะตะผะฐัั{}, // ะทะฐะดัะตะผะฐัั ะฒ ะบัะพะฒะฐัะธ
rus_verbs:ััะณะฐัััั{}, // ััะณะฐัััั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ะทะฐะทะฒััะฐัั{}, // ะทะฐะทะฒััะฐัั ะฒ ัะฐะดะธะพะฟัะธะตะผะฝะธะบะฐั
rus_verbs:ะทะฐะดะพั
ะฝััััั{}, // ะทะฐะดะพั
ะฝััััั ะฒ ะฒะพะดะต
rus_verbs:ะฟะพัะพะถะดะฐัั{}, // ะฟะพัะพะถะดะฐัั ะฒ ะฝะตะพะบัะตะฟัะธั
ัะผะฐั
rus_verbs:ะพัะดัั
ะฐัั{}, // ะพัะดัั
ะฐัั ะฒ ัะฐะฝะฐัะพัะธะธ
rus_verbs:ัะฟะพะผะธะฝะฐัััั{}, // ัะฟะพะผะธะฝะฐัััั ะฒ ะฟัะตะดัะดััะตะผ ัะพะพะฑัะตะฝะธะธ
rus_verbs:ะพะฑัะฐะทะพะฒะฐัั{}, // ะพะฑัะฐะทะพะฒะฐัั ะฒ ะฟัะพะฑะธัะบะต ัะตะผะฝัั ะฒะทะฒะตัั
rus_verbs:ะพัะผะตัะฐัั{}, // ะพัะผะตัะฐัั ะฒ ัะฟะธัะบะต
rus_verbs:ะฟะพะดัะตัะบะฝััั{}, // ะฟะพะดัะตัะบะฝััั ะฒ ะฑะปะพะบะฝะพัะต
rus_verbs:ะฟะปััะฐัั{}, // ะฟะปััะฐัั ะฒ ะพัะบััะถะตะฝะธะธ ะฝะตะทะฝะฐะบะพะผัั
ะปัะดะตะน
rus_verbs:ะฟะพะฒััะธัั{}, // ะฟะพะฒััะธัั ะฒ ะทะฒะฐะฝะธะธ
rus_verbs:ะฟะพะดะถะธะดะฐัั{}, // ะฟะพะดะถะธะดะฐัั ะฒ ะฟะพะดัะตะทะดะต
rus_verbs:ะพัะบะฐะทะฐัั{}, // ะพัะบะฐะทะฐัั ะฒ ะฟะตัะตัะผะพััะต ะดะตะปะฐ
rus_verbs:ัะฐััะฒะพัะธัััั{}, // ัะฐััะฒะพัะธัััั ะฒ ะฑะตะฝะทะธะฝะต
rus_verbs:ะพััะฐะถะฐัั{}, // ะพััะฐะถะฐัั ะฒ ััะธั
ะฐั
rus_verbs:ะดัะตะผะฐัั{}, // ะดัะตะผะฐัั ะฒ ะณะฐะผะฐะบะต
rus_verbs:ะฟัะธะผะตะฝััััั{}, // ะฟัะธะผะตะฝััััั ะฒ ะดะพะผะฐัะฝะธั
ััะปะพะฒะธัั
rus_verbs:ะฟัะธัะฝะธัััั{}, // ะฟัะธัะฝะธัััั ะฒะพ ัะฝะต
rus_verbs:ัััััะธัั{}, // ัััััะธัั ะฒ ะดัะฐะฝะดัะปะตัะต
rus_verbs:ัะพั
ัะฐะฝััั{}, // ัะพั
ัะฐะฝััั ะฒ ะฝะตะฟัะธะบะพัะฝะพะฒะตะฝะฝะพััะธ
rus_verbs:ัะฐััััะตะปััั{}, // ัะฐััััะตะปััั ะฒ ะปะพะถะฑะธะฝะต
rus_verbs:ัะฐัััะธัะฐัั{}, // ัะฐัััะธัะฐัั ะฒ ะฟัะพะณัะฐะผะผะต
rus_verbs:ะฟะตัะตะฑะธัะฐัั{}, // ะฟะตัะตะฑะธัะฐัั ะฒ ััะบะต
rus_verbs:ัะฐะทะฑะธัััั{}, // ัะฐะทะฑะธัััั ะฒ ะฐะฒะฐัะธะธ
rus_verbs:ะฟะพะธัะบะฐัั{}, // ะฟะพะธัะบะฐัั ะฒ ัะณะปั
rus_verbs:ะผััะธัััั{}, // ะผััะธัััั ะฒ ัะตัะฝะพะน ะบะปะตัะบะต
rus_verbs:ะทะฐะผะตะปัะบะฐัั{}, // ะทะฐะผะตะปัะบะฐัั ะฒ ัะตะปะตะฒะธะทะพัะต
rus_verbs:ะณััััะธัั{}, // ะณััััะธัั ะฒ ะพะดะธะฝะพัะตััะฒะต
rus_verbs:ะบัััะธัั{}, // ะบัััะธัั ะฒ ะฑะฐะฝะบะต
rus_verbs:ะพะฑััะฒะธัััั{}, // ะพะฑััะฒะธัััั ะฒ ะณะพัะพะดะต
rus_verbs:ะฟะพะดะณะพัะพะฒะธัั{}, // ะฟะพะดะณะพัะพะฒะธัั ะฒ ัะฐะนะฝะต
rus_verbs:ัะฐะทะปะธัะฐัั{}, // ัะฐะทะปะธัะฐัั ะฒ ัะผะตัะธ
rus_verbs:ะพะฑะฝะฐััะถะธะฒะฐัั{}, // ะพะฑะฝะฐััะถะธะฒะฐัั ะฒ ะบัะพะฒะธ
rus_verbs:ะบะธัะฝััั{}, // ะบะธัะฝััั ะฒ ะทะฐั
ะพะปััััะต
rus_verbs:ะพะฑะพัะฒะฐัััั{}, // ะพะฑะพัะฒะฐัััั ะฒ ะฝะฐัะฐะปะต ััะฐะทั
rus_verbs:ะทะฐะฟััะฐัััั{}, // ะทะฐะฟััะฐัััั ะฒ ะฒะตัะตะฒะบะฐั
rus_verbs:ะพะฑัะฐัััั{}, // ะพะฑัะฐัััั ะฒ ะธะฝัะธะผะฝะพะน ะพะฑััะฐะฝะพะฒะบะต
rus_verbs:ัะพัะธะฝะธัั{}, // ัะพัะธะฝะธัั ะฒ ัะตััะพัะฐะฝะต
rus_verbs:ะธะทะพะฑัะตััะธ{}, // ะธะทะพะฑัะตััะธ ะฒ ะดะพะผะฐัะฝะตะน ะปะฐะฑะพัะฐัะพัะธะธ
rus_verbs:ะฟัะพะบะพะผะผะตะฝัะธัะพะฒะฐัั{}, // ะฟัะพะบะพะผะผะตะฝัะธัะพะฒะฐัั ะฒ ัะฒะพะตะผ ะฑะปะพะณะต
rus_verbs:ะดะฐะฒะธัั{}, // ะดะฐะฒะธัั ะฒ ะทะฐัะพะดััะต
rus_verbs:ะฟะพะฒัะพัะธัััั{}, // ะฟะพะฒัะพัะธัััั ะฒ ะฝะพะฒะพะผ ะพะฑะปะธััะต
rus_verbs:ะพัััะฐะฒะฐัั{}, // ะพัััะฐะฒะฐัั ะฒ ะพะฑัะตะผ ะทะฐัะตัะต
rus_verbs:ัะฐะทัะฐะฑะพัะฐัั{}, // ัะฐะทัะฐะฑะพัะฐัั ะฒ ะปะฐะฑะพัะฐัะพัะธะธ
rus_verbs:ะบะฐัะฐัั{}, // ะบะฐัะฐัั ะฒ ะบัะพะฒะฐัะบะต
rus_verbs:ะทะฐะผะตะฝะธัั{}, // ะทะฐะผะตะฝะธัั ะฒ ะดะฒะธะณะฐัะตะปะต
rus_verbs:ะทะฐะดัั
ะฐัััั{}, // ะทะฐะดัั
ะฐัััั ะฒ ะดััะฝะพะน ะธ ะฒะปะฐะถะฝะพะน ะฐัะผะพััะตัะต
rus_verbs:ะทะฐะฑะตะณะฐัั{}, // ะทะฐะฑะตะณะฐัั ะฒ ัะฟะตัะบะต
rus_verbs:ะฝะฐะดะตะปะฐัั{}, // ะฝะฐะดะตะปะฐัั ะฒ ัะตัะตะฝะธะธ ะพัะธะฑะพะบ
rus_verbs:ะธัะบะฐะทะธัััั{}, // ะธัะบะฐะทะธัััั ะฒ ะบัะธะฒะพะผ ะทะตัะบะฐะปะต
rus_verbs:ัััะธัั{}, // ัััะธัั ะฒ ะฟะพะผะตัะตะฝะธะธ ะฟะพะถะฐั
rus_verbs:ะพั
ัะฐะฝััั{}, // ะพั
ัะฐะฝััั ะฒ ะทะดะฐะฝะธะธ ะฒั
ะพะดั
rus_verbs:ะฟัะธะผะตัะธัั{}, // ะฟัะธะผะตัะธัั ะฒ ะบัััะฐั
rus_verbs:ัะบัััั{}, // ัะบัััั ะฒ ัะบะปะฐะดะบะฐั
ะพะดะตะถะดั
rus_verbs:ัะดะตัะถะธะฒะฐัั{}, // ัะดะตัะถะธะฒะฐัั ะฒ ะทะฐะปะพะถะฝะธะบะฐั
rus_verbs:ัะฒะตะปะธัะธะฒะฐัััั{}, // ัะฒะตะปะธัะธะฒะฐัััั ะฒ ัะฐะทะผะตัะต
rus_verbs:ะบัะฐัะพะฒะฐัััั{}, // ะบัะฐัะพะฒะฐัััั ะฒ ะฝะพะฒะพะผ ะฟะปะฐััะต
rus_verbs:ัะพั
ัะฐะฝะธัััั{}, // ัะพั
ัะฐะฝะธัััั ะฒ ัะตะฟะปะต
rus_verbs:ะปะตัะธัั{}, // ะปะตัะธัั ะฒ ััะฐัะธะพะฝะฐัะต
rus_verbs:ัะผะตัะฐัััั{}, // ัะผะตัะฐัััั ะฒ ะฑะฐะบะต
rus_verbs:ะฟัะพะบะฐัะธัััั{}, // ะฟัะพะบะฐัะธัััั ะฒ ััะพะปะปะตะนะฑััะต
rus_verbs:ะดะพะณะพะฒะฐัะธะฒะฐัััั{}, // ะดะพะณะพะฒะฐัะธะฒะฐัััั ะฒ ะทะฐะบัััะพะผ ะบะฐะฑะธะฝะตัะต
rus_verbs:ะพะฟัะฑะปะธะบะพะฒะฐัั{}, // ะพะฟัะฑะปะธะบะพะฒะฐัั ะฒ ะพัะธัะธะฐะปัะฝะพะผ ะฑะปะพะณะต
rus_verbs:ะพั
ะพัะธัััั{}, // ะพั
ะพัะธัััั ะฒ ะฟัะตัะธัั
rus_verbs:ะพััะฐะถะฐัััั{}, // ะพััะฐะถะฐัััั ะฒ ะพะบะฝะต
rus_verbs:ะฟะพะฝะธะทะธัั{}, // ะฟะพะฝะธะทะธัั ะฒ ะดะพะปะถะฝะพััะธ
rus_verbs:ะพะฑะตะดะฐัั{}, // ะพะฑะตะดะฐัั ะฒ ัะตััะพัะฐะฝะต
rus_verbs:ะฟะพัะธะดะตัั{}, // ะฟะพัะธะดะตัั ะฒ ัะตะฝะธ
rus_verbs:ัะพะพะฑัะฐัััั{}, // ัะพะพะฑัะฐัััั ะฒ ะพะฟะฟะพะทะธัะธะพะฝะฝะพะน ะณะฐะทะตัะต
rus_verbs:ัะฒะตััะธัััั{}, // ัะฒะตััะธัััั ะฒ ััะดะต
rus_verbs:ะฝะพัะตะฒะฐัั{}, // ะฝะพัะตะฒะฐัั ะฒ ะณะพััะธะฝะธัะต
rus_verbs:ัะตะผะฝะตัั{}, // ัะตะผะฝะตัั ะฒ ะฒะพะดะต
rus_verbs:ะณะธะฑะฝััั{}, // ะณะธะฑะฝััั ะฒ ะทะฐััะตะฝะบะฐั
rus_verbs:ััะธะปะธะฒะฐัััั{}, // ััะธะปะธะฒะฐัััั ะฒ ะฝะฐะฟัะฐะฒะปะตะฝะธะธ ะณะปะฐะฒะฝะพะณะพ ัะดะฐัะฐ
rus_verbs:ัะฐัะฟะปััััั{}, // ัะฐัะฟะปััััั ะฒ ัะปัะฑะบะต
rus_verbs:ะฟัะตะฒััะฐัั{}, // ะฟัะตะฒััะฐัั ะฒ ะฝะตัะบะพะปัะบะพ ัะฐะท
rus_verbs:ะฟัะพะถะธะฒะฐัั{}, // ะฟัะพะถะธะฒะฐัั ะฒ ะพัะดะตะปัะฝะพะน ะบะพะผะพัะบะต
rus_verbs:ะณะพะปัะฑะตัั{}, // ะณะพะปัะฑะตัั ะฒ ัะตะฟะปะต
rus_verbs:ะธััะปะตะดะพะฒะฐัั{}, // ะธััะปะตะดะพะฒะฐัั ะฒ ะตััะตััะฒะตะฝะฝัั
ััะปะพะฒะธัั
rus_verbs:ะพะฑะธัะฐัั{}, // ะพะฑะธัะฐัั ะฒ ะปะตัั
rus_verbs:ัะบััะฐัั{}, // ัะบััะฐัั ะฒ ะพะดะธะฝะพัะตััะฒะต
rus_verbs:ััะฐะปะบะธะฒะฐัััั{}, // ััะฐะปะบะธะฒะฐัััั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ัะฐะธัััั{}, // ัะฐะธัััั ะฒ ะณะปัะฑะธะฝะต
rus_verbs:ัะฟะฐัะฐัั{}, // ัะฟะฐัะฐัั ะฒ ะผะพัะต
rus_verbs:ะทะฐะฑะปัะดะธัััั{}, // ะทะฐะฑะปัะดะธัััั ะฒ ะปะตัั
rus_verbs:ัะพะทะดะฐัััั{}, // ัะพะทะดะฐัััั ะฒ ะฝะพะฒะพะผ ะฒะธะดะต
rus_verbs:ะฟะพัะฐัะธัั{}, // ะฟะพัะฐัะธัั ะฒ ะบะฐัะผะฐะฝะต
rus_verbs:ะฟะปะฐะฝะธัะพะฒะฐัั{}, // ะฟะปะฐะฝะธัะพะฒะฐัั ะฒ ะฟัะพะณัะฐะผะผะต
rus_verbs:ะพัะฑะธัั{}, // ะพัะฑะธัั ะฒ ะฝะธะถะฝะตะน ัะฐััะธ
rus_verbs:ะพััะธัะฐัั{}, // ะพััะธัะฐัั ะฒ ััะดะต ัะฒะพั ะฒะธะฝั
rus_verbs:ะพัะฝะพะฒะฐัั{}, // ะพัะฝะพะฒะฐัั ะฒ ะฟััััะฝะต ะฝะพะฒัะน ะณะพัะพะด
rus_verbs:ะดะฒะพะธัั{}, // ะดะฒะพะธัั ะฒ ะณะปะฐะทะฐั
rus_verbs:ัััะพััั{}, // ัััะพััั ะฒ ะปะพะดะบะต
rus_verbs:ัะฝััั{}, // ัะฝััั ะฒ ะฝะพะณะฐั
ะดัะพะถั
rus_verbs:ะพัะทัะฒะฐัััั{}, // ะพัะทัะฒะฐัััั ะฒ ะพะฑะทะพัะต
rus_verbs:ะฟัะธัะพัะผะพะทะธัั{}, // ะฟัะธัะพัะผะพะทะธัั ะฒ ััะฐะฒะต
rus_verbs:ัะธัะฐัััั{}, // ัะธัะฐัััั ะฒ ะณะปะฐะทะฐั
rus_verbs:ะถะธัััั{}, // ะถะธัััั ะฒ ะดะตัะตะฒะฝะต
rus_verbs:ะทะฐะธะณัะฐัั{}, // ะทะฐะธะณัะฐัั ะฒ ะถะธะปะฐั
rus_verbs:ัะตะฒะตะปะธัั{}, // ัะตะฒะตะปะธัั ะฒ ะฒะพะดะต
rus_verbs:ะทะฐะทะฒะตะฝะตัั{}, // ะทะฐะทะฒะตะฝะตัั ะฒ ััะฐั
rus_verbs:ะทะฐะฒะธัะฝััั{}, // ะทะฐะฒะธัะฝััั ะฒ ะฑะธะฑะปะธะพัะตะบะต
rus_verbs:ะทะฐัะฐะธัั{}, // ะทะฐัะฐะธัั ะฒ ะดััะต ะพะฑะธะดั
rus_verbs:ัะพะทะฝะฐัััั{}, // ัะพะทะฝะฐัััั ะฒ ัะพะฒะตััะตะฝะธะธ
rus_verbs:ะฟัะพัะตะบะฐัั{}, // ะฟัะพัะตะบะฐัั ะฒ ะปะตะณะบะพะน ัะพัะผะต
rus_verbs:ะฒัััะฝััััั{}, // ะฒัััะฝััััั ะฒ ั
ะพะดะต ัะบัะฟะตัะธะผะตะฝัะฐ
rus_verbs:ัะบัะตััะธัั{}, // ัะบัะตััะธัั ะฒ ะฝะตะฒะพะปะต
rus_verbs:ะฝะฐะฒะพะดะธัั{}, // ะฝะฐะฒะพะดะธัั ะฒ ะบะพะผะฝะฐัะต ะฟะพััะดะพะบ
rus_verbs:ะทะฝะฐัะธัััั{}, // ะทะฝะฐัะธัััั ะฒ ะดะพะบัะผะตะฝัะฐั
rus_verbs:ะทะฐะธะฝัะตัะตัะพะฒะฐัั{}, // ะทะฐะธะฝัะตัะตัะพะฒะฐัั ะฒ ะฟะพะปััะตะฝะธะธ ัะตะทัะปััะฐัะพะฒ
rus_verbs:ะฟะพะทะฝะฐะบะพะผะธัั{}, // ะฟะพะทะฝะฐะบะพะผะธัั ะฒ ะฝะตะฟัะธะฝัะถะดะตะฝะฝะพะน ะพะฑััะฐะฝะพะฒะบะต
rus_verbs:ัะฐััะตััััั{}, // ัะฐััะตััััั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ะณัะพั
ะฝััั{}, // ะณัะพั
ะฝััั ะฒ ะฟะพะดะฒะฐะปะต
rus_verbs:ะพะฑะฒะธะฝััั{}, // ะพะฑะฒะธะฝััั ะฒ ะฒัะผะพะณะฐัะตะปัััะฒะต
rus_verbs:ััะพะปะฟะธัััั{}, // ััะพะปะฟะธัััั ะฒ ัะพะนะต
rus_verbs:ะฟะพัััััั{}, // ะฟะพัััััั ะฒ ััะผะบะต
rus_verbs:ะพัะปะฐะฑะธัั{}, // ะพัะปะฐะฑะธัั ะฒ ะฒะตัั
ะฝะตะน ัะฐััะธ
rus_verbs:ะพะฑะฝะฐััะถะธะฒะฐัััั{}, // ะพะฑะฝะฐััะถะธะฒะฐัััั ะฒ ะบะฐัะผะฐะฝะต ะบัััะบะธ
rus_verbs:ัะฟะฐััะธัั{}, // ัะฟะฐััะธัั ะฒ ั
ะธะถะธะฝะต
rus_verbs:ะฟัะตัะฒะฐัััั{}, // ะฟัะตัะฒะฐัััั ะฒ ัะตัะตะดะธะฝะต ััะฐะทั
rus_verbs:ะฟัะธะผะตะฝััั{}, // ะฟัะธะผะตะฝััั ะฒ ะฟะพะฒัะตะดะฝะตะฒะฝะพะน ัะฐะฑะพัะต
rus_verbs:ัััะพะธัััั{}, // ัััะพะธัััั ะฒ ะทะพะฝะต ะพัััะถะดะตะฝะธั
rus_verbs:ะฟััะตัะตััะฒะพะฒะฐัั{}, // ะฟััะตัะตััะฒะพะฒะฐัั ะฒ ัะฐะผะพะปะตัะต
rus_verbs:ะฟะพะฑะตะถะดะฐัั{}, // ะฟะพะฑะตะถะดะฐัั ะฒ ัะตััะฝะพะน ะฑะธัะฒะต
rus_verbs:ะฟะพะณัะฑะธัั{}, // ะฟะพะณัะฑะธัั ะฒ ัะตะฑะต ะฐััะธััะฐ
rus_verbs:ัะฐััะผะฐััะธะฒะฐัััั{}, // ัะฐััะผะฐััะธะฒะฐัััั ะฒ ัะปะตะดัััะตะน ะณะปะฐะฒะต
rus_verbs:ะฟัะพะดะฐะฒะฐัััั{}, // ะฟัะพะดะฐะฒะฐัััั ะฒ ัะฟะตัะธะฐะปะธะทะธัะพะฒะฐะฝะฝะพะผ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ัะฐะทะผะตััะธัััั{}, // ัะฐะทะผะตััะธัััั ะฒ ะฐัะดะธัะพัะธะธ
rus_verbs:ะฟะพะฒะธะดะฐัั{}, // ะฟะพะฒะธะดะฐัั ะฒ ะถะธะทะฝะธ
rus_verbs:ะฝะฐััะธะณะฝััั{}, // ะฝะฐััะธะณะฝััั ะฒ ะฟัะธะณะพัะพะดะฐั
rus_verbs:ัะณััะดะธัััั{}, // ัะณััะดะธัััั ะฒ ัะตะฝััะต ะทะฐะณะพะฝะฐ
rus_verbs:ัะบัััััั{}, // ัะบัััััั ะฒ ะดะพะผะต
rus_verbs:ัะฐัะฟะปะฐะบะฐัััั{}, // ัะฐัะฟะปะฐะบะฐัััั ะฒ ััะดะต
rus_verbs:ะฟัะพะปะตะถะฐัั{}, // ะฟัะพะปะตะถะฐัั ะฒ ะบะฐะฝะฐะฒะต
rus_verbs:ะทะฐะผะตัะทะฝััั{}, // ะทะฐะผะตัะทะฝััั ะฒ ะปะตะดัะฝะพะน ะฒะพะดะต
rus_verbs:ะฟะพัะบะพะปัะทะฝััััั{}, // ะฟะพัะบะพะปัะทะฝััััั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ัะฐัะบะฐัั{}, // ัะฐัะบะฐัั ะฒ ััะบะฐั
rus_verbs:ะฝะฐะฟะฐะดะฐัั{}, // ะฝะฐะฟะฐะดะฐัั ะฒ ะฒะพะปัะตัะต
rus_verbs:ะฟัะพัะผะฐััะธะฒะฐัั{}, // ะฟัะพัะผะฐััะธะฒะฐัั ะฒ ะฑัะฐัะทะตัะต
rus_verbs:ะพะฑะดัะผะฐัั{}, // ะพะฑะดัะผะฐัั ะฒ ะดะพัะพะณะต
rus_verbs:ะพะฑะฒะธะฝะธัั{}, // ะพะฑะฒะธะฝะธัั ะฒ ะธะทะผะตะฝะต
rus_verbs:ะพััะฐะฝะฐะฒะปะธะฒะฐัั{}, // ะพััะฐะฝะฐะฒะปะธะฒะฐัั ะฒ ะดะฒะตััั
rus_verbs:ัะตัััััั{}, // ัะตัััััั ะฒ ะดะพะณะฐะดะบะฐั
rus_verbs:ะฟะพะณะธะฑะฐัั{}, // ะฟะพะณะธะฑะฐัั ะฒ ะฑะพั
rus_verbs:ะพะฑะพะทะฝะฐัะฐัั{}, // ะพะฑะพะทะฝะฐัะฐัั ะฒ ัะฟะธัะบะต
rus_verbs:ะทะฐะฟัะตัะฐัั{}, // ะทะฐะฟัะตัะฐัั ะฒ ะฟะฐัะบะต
rus_verbs:ะดะพะปะตัะตัั{}, // ะดะพะปะตัะตัั ะฒ ะฒะตััะพะปััะต
rus_verbs:ัะตัะฝะธัััั{}, // ัะตัะฝะธัััั ะฒ ะบะฐะผะพัะบะต
rus_verbs:ัะผะตะฝััะฐัััั{}, // ัะผะตะฝััะฐัััั ะฒ ัะฐะทะผะตัะต
rus_verbs:ะธะทะดะฐะฒะฐัั{}, // ะธะทะดะฐะฒะฐัั ะฒ ะฝะตะฑะพะปััะพะผ ะธะทะดะฐัะตะปัััะฒะต
rus_verbs:ั
ะพัะพะฝะธัั{}, // ั
ะพัะพะฝะธัั ะฒ ะผะพัะต
rus_verbs:ะฟะตัะตะผะตะฝะธัััั{}, // ะฟะตัะตะผะตะฝะธัััั ะฒ ะปะธัะต
rus_verbs:ัััะฐะฝะพะฒะธัััั{}, // ัััะฐะฝะพะฒะธัััั ะฒ ัะตะฒะตัะฝัั
ะพะฑะปะฐัััั
rus_verbs:ะฟัะธะบะธะดัะฒะฐัั{}, // ะฟัะธะบะธะดัะฒะฐัั ะฒ ัะผะต
rus_verbs:ะทะฐัะฐะธัััั{}, // ะทะฐัะฐะธัััั ะฒ ััะฐะฒะต
rus_verbs:ัะฐะทะดะพะฑััั{}, // ัะฐะทะดะพะฑััั ะฒ ะฐะฟัะตะบะต
rus_verbs:ะฟะตัะตะฑัะพัะธัั{}, // ะฟะตัะตะฑัะพัะธัั ะฒ ัะพะฒะฐัะฝะพะผ ัะพััะฐะฒะต
rus_verbs:ะฟะพะณััะถะฐัััั{}, // ะฟะพะณััะถะฐัััั ะฒ ะฑะฐัะธัะบะฐัะต
rus_verbs:ะฟะพะถะธะฒะฐัั{}, // ะฟะพะถะธะฒะฐัั ะฒ ะพะดะธะฝะพัะตััะฒะต
rus_verbs:ะฟัะธะทะฝะฐะฒะฐัััั{}, // ะฟัะธะทะฝะฐะฒะฐัััั ะฒ ะปัะฑะฒะธ
rus_verbs:ะทะฐั
ะฒะฐััะฒะฐัั{}, // ะทะฐั
ะฒะฐััะฒะฐัั ะฒ ะทะดะฐะฝะธะธ
rus_verbs:ะฟะพะบะฐัะธะฒะฐัััั{}, // ะฟะพะบะฐัะธะฒะฐัััั ะฒ ะปะพะดะบะต
rus_verbs:ะบัััะธัััั{}, // ะบัััะธัััั ะฒ ะบะพะปะตัะต
rus_verbs:ะฟะพะผะตัะฐัััั{}, // ะฟะพะผะตัะฐัััั ะฒ ััะธะบะต
rus_verbs:ะฟะธัะฐัััั{}, // ะฟะธัะฐัััั ะฒ ััะพะปะพะฒะพะน
rus_verbs:ะพัะดะพั
ะฝััั{}, // ะพัะดะพั
ะฝััั ะฒ ะฟะฐะฝัะธะพะฝะฐัะต
rus_verbs:ะบะฐัะฐัััั{}, // ะบะฐัะฐัััั ะฒ ะบะพะปััะบะต
rus_verbs:ะฟะพัะฐะฑะพัะฐัั{}, // ะฟะพัะฐะฑะพัะฐัั ะฒ ัะตั
ั
rus_verbs:ะฟะพะดัะฐะทัะผะตะฒะฐัั{}, // ะฟะพะดัะฐะทัะผะตะฒะฐัั ะฒ ะทะฐะดะฐะฝะธะธ
rus_verbs:ะพะณัะฐะฑะธัั{}, // ะพะณัะฐะฑะธัั ะฒ ะฟะพะดะฒะพัะพัะฝะต
rus_verbs:ะฟัะตััะฟะตัั{}, // ะฟัะตััะฟะตัั ะฒ ะฑะธะทะฝะตัะต
rus_verbs:ะทะฐะตัะทะฐัั{}, // ะทะฐะตัะทะฐัั ะฒ ะบัะตัะปะต
rus_verbs:ัะฐะทัััะฝะธัั{}, // ัะฐะทัััะฝะธัั ะฒ ะดััะณะพะน ััะฐััะต
rus_verbs:ะฟัะพะดะฒะธะฝััััั{}, // ะฟัะพะดะฒะธะฝััััั ะฒ ะธะทััะตะฝะธะธ
rus_verbs:ะฟะพะบะพะปะตะฑะฐัััั{}, // ะฟะพะบะพะปะตะฑะฐัััั ะฒ ะฝะฐัะฐะปะต
rus_verbs:ะทะฐัะพะผะฝะตะฒะฐัััั{}, // ะทะฐัะพะผะฝะตะฒะฐัััั ะฒ ัะตััะฝะพััะธ
rus_verbs:ะฟัะธะฝะธะบะฝััั{}, // ะฟัะธะฝะธะบะฝััั ะฒ ัะผะต
rus_verbs:ัะบัะธะฒะธัั{}, // ัะบัะธะฒะธัั ะฒ ััะผะตัะบะต
rus_verbs:ัะฐััะตัั{}, // ัะฐััะตัั ะฒ ัะตะฝััะต ะพะฟัั
ะพะปะธ
rus_verbs:ะฟะตัะตะฟััะฐัั{}, // ะฟะตัะตะฟััะฐัั ะฒ ัะพะดะดะพะผะต
rus_verbs:ะฟะพัะผะตััััั{}, // ะฟะพัะผะตััััั ะฒ ะฟะตัะตััะฒะต
rus_verbs:ะพัะผะตัะฐัััั{}, // ะพัะผะตัะฐัััั ะฒ ะฟะพะปะธัะตะนัะบะพะผ ััะฐััะบะต
rus_verbs:ะฝะฐะบะพะฟะธัััั{}, // ะฝะฐะบะพะฟะธัััั ะฒ ะพัััะพะนะฝะธะบะต
rus_verbs:ัะฝะพัะธัั{}, // ัะฝะพัะธัั ะฒ ััะบะฐั
rus_verbs:ะฝะฐะฒะตัะฐัั{}, // ะฝะฐะฒะตัะฐัั ะฒ ะฑะพะปัะฝะธัะต
rus_verbs:ะพััััั{}, // ะพััััั ะฒ ะฟัะพัะพัะฝะพะน ะฒะพะดะต
rus_verbs:ะทะฐะฟะตัะตัััั{}, // ะทะฐะฟะตัะตัััั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ะพะฑะพะณะฝะฐัั{}, // ะพะฑะพะณะฝะฐัั ะฒ ะฟะตัะฒะพะผ ะบััะณะต
rus_verbs:ัะฑะตะถะดะฐัััั{}, // ัะฑะตะถะดะฐัััั ะฒ ะฝะตะธะทะฑะตะถะฝะพััะธ
rus_verbs:ะฟะพะดะฑะธัะฐัั{}, // ะฟะพะดะฑะธัะฐัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ัะฝะธััะพะถะฐัั{}, // ัะฝะธััะพะถะฐัั ะฒ ะฟะพะปะตัะต
rus_verbs:ะฟััะฐัััั{}, // ะฟััะฐัััั ะฒ ะฟะพะบะฐะทะฐะฝะธัั
rus_verbs:ะฟัะธัะฐะธัััั{}, // ะฟัะธัะฐะธัััั ะฒ ัะตะผะฝะพัะต
rus_verbs:ะฟัะพะฟะปัะฒะฐัั{}, // ะฟัะพะฟะปัะฒะฐัั ะฒ ะปะพะดะบะต
rus_verbs:ะทะฐัะตััั{}, // ะทะฐัะตััั ะฒ ะพะบะพะฟะต
rus_verbs:ะฟะพะดัะตะฟะธัั{}, // ะฟะพะดัะตะฟะธัั ะฒ ะฑะฐัะต
rus_verbs:ะฝะฐััะธัะฐัั{}, // ะฝะฐััะธัะฐัั ะฒ ะดะธะบัะฐะฝัะต ะฝะตัะบะพะปัะบะพ ะพัะธะฑะพะบ
rus_verbs:ะพะฟัะฐะฒะดะฐัััั{}, // ะพะฟัะฐะฒะดะฐัััั ะฒ ััะดะต
rus_verbs:ัะพะทัะตัั{}, // ัะพะทัะตัั ะฒ ะตััะตััะฒะตะฝะฝัั
ััะปะพะฒะธัั
rus_verbs:ัะฐัะบััะฒะฐัััั{}, // ัะฐัะบััะฒะฐัััั ะฒ ะฟะพะดั
ะพะดััะธั
ััะปะพะฒะธัั
rus_verbs:ะพะถะธะดะฐัััั{}, // ะพะถะธะดะฐัััั ะฒ ะฒะตัั
ะฝะตะน ัะฐััะธ
rus_verbs:ะพะดะตะฒะฐัััั{}, // ะพะดะตะฒะฐัััั ะฒ ะดะพัะพะณะธั
ะฑััะธะบะฐั
rus_verbs:ัะฟัะตะบะฝััั{}, // ัะฟัะตะบะฝััั ะฒ ะฝะตะดะพััะฐัะบะต ะพะฟััะฐ
rus_verbs:ะณัะฐะฑะธัั{}, // ะณัะฐะฑะธัั ะฒ ะฟะพะดะฒะพัะพัะฝะต
rus_verbs:ัะถะธะฝะฐัั{}, // ัะถะธะฝะฐัั ะฒ ัะตััะพัะฐะฝะต
rus_verbs:ะณะพะฝััั{}, // ะณะพะฝััั ะฒ ะถะธะปะฐั
rus_verbs:ัะฒะตัะธัั{}, // ัะฒะตัะธัั ะฒ ะฑะตะทะพะฟะฐัะฝะพััะธ
rus_verbs:ะฟะพัะตัััััั{}, // ะฟะพัะตัััััั ะฒ ะปะตัั
rus_verbs:ัััะฐะฝะฐะฒะปะธะฒะฐัััั{}, // ัััะฐะฝะฐะฒะปะธะฒะฐัััั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ะฟัะตะดะพััะฐะฒะปััั{}, // ะฟัะตะดะพััะฐะฒะปััั ะฒ ััะดะต
rus_verbs:ะฟัะพััะฝััััั{}, // ะฟัะพััะฝััััั ะฒ ััะตะฝะต
rus_verbs:ะดะพะฟัะฐัะธะฒะฐัั{}, // ะดะพะฟัะฐัะธะฒะฐัั ะฒ ะฑัะฝะบะตัะต
rus_verbs:ะฟัะพัะฐะฑะพัะฐัั{}, // ะฟัะพัะฐะฑะพัะฐัั ะฒ ะบะฐะฑะธะฝะตัะต
rus_verbs:ัะพััะตะดะพัะพัะธัั{}, // ัะพััะตะดะพัะพัะธัั ะฒ ัะฒะพะธั
ััะบะฐั
rus_verbs:ััะฒะตัะดะธัั{}, // ััะฒะตัะดะธัั ะฒ ะดะพะปะถะฝะพััะธ
rus_verbs:ัะพัะธะฝััั{}, // ัะพัะธะฝััั ะฒ ะดะพัะพะณะต
rus_verbs:ะฟะพะผะตัะบะฝััั{}, // ะฟะพะผะตัะบะฝััั ะฒ ะณะปะฐะทะฐั
rus_verbs:ะฟะพะบะฐะทัะฒะฐัััั{}, // ะฟะพะบะฐะทัะฒะฐัััั ะฒ ะพะบะพัะบะต
rus_verbs:ะฟะพั
ัะดะตัั{}, // ะฟะพั
ัะดะตัั ะฒ ัะฐะปะธะธ
rus_verbs:ะฟัะพะดะตะปัะฒะฐัั{}, // ะฟัะพะดะตะปัะฒะฐัั ะฒ ััะตะฝะต
rus_verbs:ะฟัะพัะปะฐะฒะธัััั{}, // ะฟัะพัะปะฐะฒะธัััั ะฒ ะธะฝัะตัะฝะตัะต
rus_verbs:ัะดะพั
ะฝััั{}, // ัะดะพั
ะฝััั ะฒ ะฝะธัะตัะต
rus_verbs:ัะฐัะบะธะฝััััั{}, // ัะฐัะบะธะฝััััั ะฒ ััะตะฟะธ
rus_verbs:ัะฐะทะฒะธัั{}, // ัะฐะทะฒะธัั ะฒ ัะตะฑะต ัะฟะพัะพะฑะฝะพััะธ
rus_verbs:ัััะฐะฒะฐัั{}, // ัััะฐะฒะฐัั ะฒ ัะตั
ั
rus_verbs:ัะบัะตะฟะธัั{}, // ัะบัะตะฟะธัั ะฒ ะทะตะผะปะต
rus_verbs:ัะธัะปะธัััั{}, // ัะธัะปะธัััั ะฒ ัะฟะธัะบะต
rus_verbs:ะพะฑัะฐะทะพะฒัะฒะฐัั{}, // ะพะฑัะฐะทะพะฒัะฒะฐัั ะฒ ัะผะตัะธ
rus_verbs:ะตะบะฝััั{}, // ะตะบะฝััั ะฒ ะณััะดะธ
rus_verbs:ะพะดะพะฑัััั{}, // ะพะดะพะฑัััั ะฒ ัะฒะพะตะน ัะตัะธ
rus_verbs:ะทะฐะฟะธัั{}, // ะทะฐะฟะธัั ะฒ ะพะดะธะฝะพัะตััะฒะต
rus_verbs:ะทะฐะฑััััั{}, // ะทะฐะฑััััั ะฒ ััะถะตะปะพะผ ัะฝะต
rus_verbs:ัะตัะฝะตัั{}, // ัะตัะฝะตัั ะฒ ะบะธัะปะพะน ััะตะดะต
rus_verbs:ัะฐะทะผะตัะฐัััั{}, // ัะฐะทะผะตัะฐัััั ะฒ ะณะฐัะฐะถะต
rus_verbs:ัะพะพััะดะธัั{}, // ัะพะพััะดะธัั ะฒ ะณะฐัะฐะถะต
rus_verbs:ัะฐะทะฒะธะฒะฐัั{}, // ัะฐะทะฒะธะฒะฐัั ะฒ ัะตะฑะต
rus_verbs:ะฟะฐััะธัั{}, // ะฟะฐััะธัั ะฒ ะฟะพะนะผะต
rus_verbs:ัะพัะผะธัะพะฒะฐัััั{}, // ัะพัะผะธัะพะฒะฐัััั ะฒ ะฒะตัั
ะฝะธั
ัะปะพัั
ะฐัะผะพััะตัั
rus_verbs:ะพัะปะฐะฑะฝััั{}, // ะพัะปะฐะฑะฝััั ะฒ ัะพัะปะตะฝะตะฝะธะธ
rus_verbs:ัะฐะธัั{}, // ัะฐะธัั ะฒ ัะตะฑะต
ะธะฝัะธะฝะธัะธะฒ:ะฟัะพะฑะตะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฟัะพะฑะตะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฟัะพะฑะตะณะฐัั ะฒ ัะฟะตัะบะต
rus_verbs:ะฟัะธะพััะฐะฝะพะฒะธัััั{}, // ะฟัะธะพััะฐะฝะพะฒะธัััั ะฒ ะบะพะฝัะต
rus_verbs:ัะพะฟัะฐัััั{}, // ัะพะฟัะฐัััั ะฒ ะณััะทะธ
rus_verbs:ะณัะพะผะธัั{}, // ะณัะพะผะธัั ะฒ ัะธะฝะฐะปะต
rus_verbs:ะทะฐะผะตะฝััั{}, // ะทะฐะผะตะฝััั ะฒ ะพัะฝะพะฒะฝะพะผ ัะพััะฐะฒะต
rus_verbs:ะฟะพะดัะตะทะถะฐัั{}, // ะฟะพะดัะตะทะถะฐัั ะฒ ะบะพะปััะบะฐั
rus_verbs:ะฒััะธัะปะธัั{}, // ะฒััะธัะปะธัั ะฒ ัะผะต
rus_verbs:ะทะฐะบะฐะทัะฒะฐัั{}, // ะทะฐะบะฐะทัะฒะฐัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะพัััะตััะฒะธัั{}, // ะพัััะตััะฒะธัั ะฒ ัะตะฐะปัะฝัั
ััะปะพะฒะธัั
rus_verbs:ะพะฑะพัะฝะพะฒะฐัััั{}, // ะพะฑะพัะฝะพะฒะฐัััั ะฒ ะดัะฟะปะต
rus_verbs:ะฟััะฐัั{}, // ะฟััะฐัั ะฒ ะบะฐะผะตัะต
rus_verbs:ะฟะพะผะตะฝััั{}, // ะฟะพะผะตะฝััั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ัะพะฒะตััะธัััั{}, // ัะพะฒะตััะธัััั ะฒ ััะดะต
rus_verbs:ะฟัะพะปะตัะฐัั{}, // ะฟัะพะปะตัะฐัั ะฒ ะฒะตััะพะปะตัะต
rus_verbs:ัะฑััััั{}, // ัะฑััััั ะฒะพ ัะฝะต
rus_verbs:ัะฐะทะณะพะฒะพัะธัััั{}, // ัะฐะทะณะพะฒะพัะธัััั ะฒ ะพัะดะตะปะตะฝะธะธ
rus_verbs:ะฟัะตะฟะพะดะฝะตััะธ{}, // ะฟัะตะฟะพะดะฝะตััะธ ะฒ ะบัะฐัะธะฒะพะน ัะฟะฐะบะพะฒะบะต
rus_verbs:ะฝะฐะฟะตัะฐัะฐัั{}, // ะฝะฐะฟะตัะฐัะฐัั ะฒ ัะธะฟะพะณัะฐัะธะธ
rus_verbs:ะฟัะพัะฒะฐัั{}, // ะฟัะพัะฒะฐัั ะฒ ัะตะฝััะต
rus_verbs:ัะฐัะบะฐัะธะฒะฐัััั{}, // ัะฐัะบะฐัะธะฒะฐัััั ะฒ ะบัะตัะปะต
rus_verbs:ะทะฐะดะตัะถะธะฒะฐัััั{}, // ะทะฐะดะตัะถะธะฒะฐัััั ะฒ ะดะฒะตััั
rus_verbs:ัะณะพัะฐัั{}, // ัะณะพัะฐัั ะฒ ะบะฐัะต
rus_verbs:ะฟัะพัััะฟะฐัั{}, // ะฟัะพัััะฟะฐัั ะฒ ะณะปัะฑะธะฝะต
rus_verbs:ัะฐัะธัั{}, // ัะฐัะธัั ะฒ ะผะฐัะตะผะฐัะธะบะต
rus_verbs:ัะฒะตะปะธัะธะฒะฐัั{}, // ัะฒะตะปะธัะธะฒะฐัั ะฒ ะบะพะฝัะต
rus_verbs:ัะฐััะฒะตััะธ{}, // ัะฐััะฒะตััะธ ะฒ ะพัะฐะฝะถะตัะตะต
rus_verbs:ะทะฐะบะธะฟะตัั{}, // ะทะฐะบะธะฟะตัั ะฒ ะฑะฐะบะต
rus_verbs:ะฟะพะดะปะตัะตัั{}, // ะฟะพะดะปะตัะตัั ะฒ ะฒะตััะพะปะตัะต
rus_verbs:ัััััั{}, // ัััััั ะฒ ะบััะต
rus_verbs:ะฟะพะถะธัั{}, // ะฟะพะถะธัั ะฒ ะณะพััะธะฝะธัะต
rus_verbs:ะดะพะฑะธัะฐัััั{}, // ะดะพะฑะธัะฐัััั ะฒ ะฟะพะฟััะฝะพะผ ััะฐะฝัะฟะพััะต
rus_verbs:ะฟะตัะตะบัััั{}, // ะฟะตัะตะบัััั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ะฟัะพะดะตัะถะฐัััั{}, // ะฟัะพะดะตัะถะฐัััั ะฒ ะฑะฐัะพะบะฐะผะตัะต
rus_verbs:ัะฐะทััะบะธะฒะฐัั{}, // ัะฐะทััะบะธะฒะฐัั ะฒ ัะพะปะฟะต
rus_verbs:ะพัะฒะพะฑะพะถะดะฐัั{}, // ะพัะฒะพะฑะพะถะดะฐัั ะฒ ะทะฐะปะต ััะดะฐ
rus_verbs:ะฟะพะดะผะตัะธัั{}, // ะฟะพะดะผะตัะธัั ะฒ ัะตะปะพะฒะตะบะต
rus_verbs:ะฟะตัะตะดะฒะธะณะฐัััั{}, // ะฟะตัะตะดะฒะธะณะฐัััั ะฒ ัะทะบะพะน ัะฑะบะต
rus_verbs:ะฟัะพะดัะผะฐัั{}, // ะฟัะพะดัะผะฐัั ะฒ ัะผะต
rus_verbs:ะธะทะฒะธะฒะฐัััั{}, // ะธะทะฒะธะฒะฐัััั ะฒ ััะฐะฒะต
rus_verbs:ะฟัะพัะธัะธัะพะฒะฐัั{}, // ะฟัะพัะธัะธัะพะฒะฐัั ะฒ ััะฐััะต
rus_verbs:ะฟัะพะณัะปะธะฒะฐัััั{}, // ะฟัะพะณัะปะธะฒะฐัััั ะฒ ะฟะฐัะบะต
rus_verbs:ะทะฐัะตะผะธัั{}, // ะทะฐัะตะผะธัั ะฒ ะดะฒะตัะธ
rus_verbs:ัะฒะตะปะธัะธัััั{}, // ัะฒะตะปะธัะธัััั ะฒ ะพะฑัะตะผะต
rus_verbs:ะฟัะพัะฒะธัััั{}, // ะฟัะพัะฒะธัััั ะฒ ัะตะทัะปััะฐัะฐั
rus_verbs:ะทะฐัะบะพะปัะทะธัั{}, // ะทะฐัะบะพะปัะทะธัั ะฒ ะฑะพัะธะฝะบะฐั
rus_verbs:ะฟะตัะตัะบะฐะทะฐัั{}, // ะฟะตัะตัะบะฐะทะฐัั ะฒ ัะฒะพะตะผ ะฒััััะฟะปะตะฝะธะธ
rus_verbs:ะฟัะพัะตััะพะฒะฐัั{}, // ะฟัะพัะตััะพะฒะฐัั ะฒ ะทะดะฐะฝะธะธ ะฟะฐัะปะฐะผะตะฝัะฐ
rus_verbs:ัะบะฐะทัะฒะฐัััั{}, // ัะบะฐะทัะฒะฐัััั ะฒ ะฟััะตะฒะพะดะธัะตะปะต
rus_verbs:ะบะพะฟะพัะธัััั{}, // ะบะพะฟะพัะธัััั ะฒ ะฟะตัะบะต
rus_verbs:ะฟัะพะธะณะฝะพัะธัะพะฒะฐัั{}, // ะฟัะพะธะณะฝะพัะธัะพะฒะฐัั ะฒ ัะฒะพะตะน ัะฐะฑะพัะต
rus_verbs:ะบัะฟะฐัััั{}, // ะบัะฟะฐัััั ะฒ ัะตัะบะต
rus_verbs:ะฟะพะดััะธัะฐัั{}, // ะฟะพะดััะธัะฐัั ะฒ ัะผะต
rus_verbs:ัะฐะทะฒะพะปะฝะพะฒะฐัััั{}, // ัะฐะทะฒะพะปะฝะพะฒะฐัััั ะฒ ะบะปะฐััะต
rus_verbs:ะฟัะธะดัะผัะฒะฐัั{}, // ะฟัะธะดัะผัะฒะฐัั ะฒ ัะฒะพะตะผ ะฒะพะพะฑัะฐะถะตะฝะธะธ
rus_verbs:ะฟัะตะดััะผะพััะตัั{}, // ะฟัะตะดััะผะพััะตัั ะฒ ะฟัะพะณัะฐะผะผะต
rus_verbs:ะทะฐะฒะตััะตัััั{}, // ะทะฐะฒะตััะตัััั ะฒ ะบะพะปะตัะต
rus_verbs:ะทะฐัะตัะฟะฝััั{}, // ะทะฐัะตัะฟะฝััั ะฒ ััััะต
rus_verbs:ะพัะธััะธัั{}, // ะพัะธััะธัั ะฒ ั
ะธะผะธัะตัะบะพะน ะปะฐะฑะพัะฐัะพัะธะธ
rus_verbs:ะฟัะพะทะฒะตะฝะตัั{}, // ะฟัะพะทะฒะตะฝะตัั ะฒ ะบะพัะธะดะพัะฐั
rus_verbs:ัะผะตะฝััะธัััั{}, // ัะผะตะฝััะธัััั ะฒ ัะฐะทะผะตัะต
rus_verbs:ะบะพะปัั
ะฐัััั{}, // ะบะพะปัั
ะฐัััั ะฒ ะฟัะพัะพัะฝะพะน ะฒะพะดะต
rus_verbs:ะพะทะฝะฐะบะพะผะธัััั{}, // ะพะทะฝะฐะบะพะผะธัััั ะฒ ะฐะฒัะพะฑััะต
rus_verbs:ัะถะฐัั{}, // ัะถะฐัั ะฒ ะฐัะดะธัะพัะธะธ
rus_verbs:ัะฐัะบะธะฝััั{}, // ัะฐัะบะธะฝััั ะฒ ะผะธะบัะพัะฐะนะพะฝะต
rus_verbs:ัะฐะทะปะธัััั{}, // ัะฐะทะปะธัััั ะฒ ะฒะพะดะต
rus_verbs:ัะบะฒะพะทะธัั{}, // ัะบะฒะพะทะธัั ะฒ ัะปะพะฒะฐั
rus_verbs:ะทะฐะดััะธัั{}, // ะทะฐะดััะธัั ะฒ ะพะฑัััะธัั
rus_verbs:ะพััะดะธัั{}, // ะพััะดะธัั ะฒ ะพัะพะฑะพะผ ะฟะพััะดะบะต
rus_verbs:ัะฐะทะณัะพะผะธัั{}, // ัะฐะทะณัะพะผะธัั ะฒ ัะตััะฝะพะผ ะฟะพะตะดะธะฝะบะต
rus_verbs:ะฟะพะดัะปััะฐัั{}, // ะฟะพะดัะปััะฐัั ะฒ ะบัะปัะฐัะฐั
rus_verbs:ะฟัะพะฟะพะฒะตะดะพะฒะฐัั{}, // ะฟัะพะฟะพะฒะตะดะพะฒะฐัั ะฒ ัะตะปััะบะธั
ัะฐะนะพะฝะฐั
rus_verbs:ะพะทะฐัะธัั{}, // ะพะทะฐัะธัั ะฒะพ ัะฝะต
rus_verbs:ะฟะพัะธัะฐัั{}, // ะฟะพัะธัะฐัั ะฒ ะฟัะตะดะฒะบััะตะฝะธะธ
rus_verbs:ะพะฟะธััะฒะฐัััั{}, // ะพะฟะธััะฒะฐัััั ะฒ ััะฐััะต
rus_verbs:ะบะฐัะฐัััั{}, // ะบะฐัะฐัััั ะฒ ะบัะพะฒะฐัะบะต
rus_verbs:ััะธะปะธัั{}, // ััะธะปะธัั ะฒ ัะตะฝััะต
rus_verbs:ะฟัะพั
ะฐะถะธะฒะฐัััั{}, // ะฟัะพั
ะฐะถะธะฒะฐัััั ะฒ ะฝะพะฒะพะผ ะบะพัััะผะต
rus_verbs:ะฟะพะปะตัะธัั{}, // ะฟะพะปะตัะธัั ะฒ ะฑะพะปัะฝะธัะบะต
rus_verbs:ัะฝะธะผะฐัััั{}, // ัะฝะธะผะฐัััั ะฒ ัะธะผะตะนะบะต
rus_verbs:ัััะบะฐัั{}, // ัััะบะฐัั ะฒ ะฝะฐัะธั
ะบัะฐัั
rus_verbs:ะฟะพะฟัะธะฒะตัััะฒะพะฒะฐัั{}, // ะฟะพะฟัะธะฒะตัััะฒะพะฒะฐัั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ะฟะพะดัะฒะตัะดะธัััั{}, // ะฟะพะดัะฒะตัะดะธัััั ะฒ ัะบัะฟะตัะธะผะตะฝัะต
rus_verbs:ะฟะปะตัะบะฐัััั{}, // ะฟะปะตัะบะฐัััั ะฒ ัะตะฟะปะพะน ะฒะพะดะธัะบะต
rus_verbs:ัะฐััะธัััััั{}, // ัะฐััะธัััััั ะฒ ะฟะตัะฒะพะผ ัะตะณะผะตะฝัะต
rus_verbs:ะผะตัะตัะธัััั{}, // ะผะตัะตัะธัััั ะฒ ััะผะฐะฝะต
rus_verbs:ัะณััะฐัััั{}, // ัะณััะฐัััั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ั
ัะฐะฟะตัั{}, // ั
ัะฐะฟะตัั ะฒะพ ัะฝะต
rus_verbs:ะฟะพะดะตัะถะฐัั{}, // ะฟะพะดะตัะถะฐัั ะฒ ััะบะฐั
rus_verbs:ะฝะฐะบะธะฝััััั{}, // ะฝะฐะบะธะฝััััั ะฒ ะฟะพะดะฒะพัะพัะฝะต
rus_verbs:ะฟะปะฐะฝะธัะพะฒะฐัััั{}, // ะฟะปะฐะฝะธัะพะฒะฐัััั ะฒ ะทะฐะบัััะพะผ ัะตะถะธะผะต
rus_verbs:ะฟัะพะฑัะดะธัั{}, // ะฟัะพะฑัะดะธัั ะฒ ัะตะฑะต
rus_verbs:ะฟะพะฑัะธัััั{}, // ะฟะพะฑัะธัััั ะฒ ะฒะฐะฝะฝะพะน
rus_verbs:ัะณะธะฝััั{}, // ัะณะธะฝััั ะฒ ะฟััะธะฝะต
rus_verbs:ะพะบัะตััะธัั{}, // ะพะบัะตััะธัั ะฒ ัะตัะบะฒะธ
ะธะฝัะธะฝะธัะธะฒ:ัะตะทัะผะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะตะทัะผะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะตะทัะผะธัะพะฒะฐัั ะฒ ะบะพะฝัะต ะฒััััะฟะปะตะฝะธั
rus_verbs:ะทะฐะผะบะฝััััั{}, // ะทะฐะผะบะฝััััั ะฒ ัะตะฑะต
rus_verbs:ะฟัะธะฑะฐะฒะปััั{}, // ะฟัะธะฑะฐะฒะปััั ะฒ ะฒะตัะต
rus_verbs:ะฟัะพะฟะปััั{}, // ะฟัะพะฟะปััั ะฒ ะปะพะดะบะต
rus_verbs:ัะฐััะฒะพัััััั{}, // ัะฐััะฒะพัััััั ะฒ ััะผะฐะฝะต
rus_verbs:ัะฟัะตะบะฐัั{}, // ัะฟัะตะบะฐัั ะฒ ะฝะตะฑัะตะถะฝะพััะธ
rus_verbs:ะทะฐัะตัััััั{}, // ะทะฐัะตัััััั ะฒ ะปะฐะฑะธัะธะฝัะต
rus_verbs:ะฟะตัะตัะธััะฒะฐัั{}, // ะฟะตัะตัะธััะฒะฐัั ะฒ ะฟะพะตะทะดะต
rus_verbs:ะฟะตัะตะปะตัะตัั{}, // ะฟะตัะตะปะตัะตัั ะฒ ะฒะตััะพะปะตัะต
rus_verbs:ะพะถะธะฒะฐัั{}, // ะพะถะธะฒะฐัั ะฒ ัะตะฟะปะพะน ะฒะพะดะต
rus_verbs:ะทะฐะณะปะพั
ะฝััั{}, // ะทะฐะณะปะพั
ะฝััั ะฒ ะฟะพะปะตัะต
rus_verbs:ะบะพะปัะฝััั{}, // ะบะพะปัะฝััั ะฒ ะฑะพะบั
rus_verbs:ะบะพะฟะฐัััั{}, // ะบะพะฟะฐัััั ะฒ ะบััะต
rus_verbs:ัะฐะทะฒะปะตะบะฐัััั{}, // ัะฐะทะฒะปะตะบะฐัััั ะฒ ะบะปัะฑะต
rus_verbs:ะพัะปะธะฒะฐัั{}, // ะพัะปะธะฒะฐัั ะฒ ะบัััะฐั
rus_verbs:ะทะฐะถะธัั{}, // ะทะฐะถะธัั ะฒ ะดะตัะตะฒะฝะต
rus_verbs:ะพะดะพะปะถะธัั{}, // ะพะดะพะปะถะธัั ะฒ ัะพัะตะดะฝะตะผ ะบะฐะฑะธะฝะตัะต
rus_verbs:ะทะฐะบะปะธะฝะฐัั{}, // ะทะฐะบะปะธะฝะฐัั ะฒ ัะฒะพะตะน ัะตัะธ
rus_verbs:ัะฐะทะปะธัะฐัััั{}, // ัะฐะทะปะธัะฐัััั ะฒ ะผะตะปะพัะฐั
rus_verbs:ะฟะตัะฐัะฐัััั{}, // ะฟะตัะฐัะฐัััั ะฒ ัะธะฟะพะณัะฐัะธะธ
rus_verbs:ัะณะฐะดัะฒะฐัััั{}, // ัะณะฐะดัะฒะฐัััั ะฒ ะบะพะฝัััะฐั
rus_verbs:ะพะฑััะฒะฐัั{}, // ะพะฑััะฒะฐัั ะฒ ะฝะฐัะฐะปะต
rus_verbs:ะฟะพะณะปะฐะถะธะฒะฐัั{}, // ะฟะพะณะปะฐะถะธะฒะฐัั ะฒ ะบะฐัะผะฐะฝะต
rus_verbs:ะฟะพะดะฟะธััะฒะฐัั{}, // ะฟะพะดะฟะธััะฒะฐัั ะฒ ะฟัะธัััััะฒะธะธ ะฟะพะฝัััั
rus_verbs:ะดะพะฑัะฒะฐัั{}, // ะดะพะฑัะฒะฐัั ะฒ ัะฐะทะปะพะผะต
rus_verbs:ัะบะพะฟะธัััั{}, // ัะบะพะฟะธัััั ะฒ ะฒะพัะพัะฐั
rus_verbs:ะฟะพะฒัััะตัะฐัั{}, // ะฟะพะฒัััะตัะฐัั ะฒ ะฑะฐะฝะต
rus_verbs:ัะพะฒะฟะฐััั{}, // ัะพะฒะฟะฐััั ะฒ ัะฟัะพัะตะฝะฝะพะผ ะฒะธะดะต
rus_verbs:ัะฐะทััะฒะฐัััั{}, // ัะฐะทััะฒะฐัััั ะฒ ัะพัะบะต ัะฟะฐะนะบะธ
rus_verbs:ัะปะฐะฒะปะธะฒะฐัั{}, // ัะปะฐะฒะปะธะฒะฐัั ะฒ ะดะฐััะธะบะต
rus_verbs:ะฟะพะฒัััะตัะฐัััั{}, // ะฟะพะฒัััะตัะฐัััั ะฒ ะปะธััะต
rus_verbs:ะพััะฐะทะธัั{}, // ะพััะฐะทะธัั ะฒ ะพััะตัะต
rus_verbs:ะฟะพััะฝััั{}, // ะฟะพััะฝััั ะฒ ะฟัะธะผะตัะฐะฝะธัั
rus_verbs:ะฝะฐะบะพัะผะธัั{}, // ะฝะฐะบะพัะผะธัั ะฒ ััะพะปะพะฒะบะต
rus_verbs:ะฟะพัะถะธะฝะฐัั{}, // ะฟะพัะถะธะฝะฐัั ะฒ ัะตััะพัะฐะฝะต
ะธะฝัะธะฝะธัะธะฒ:ัะฟะตัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฟะตัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะฟะตัั ะฒ ััะดะต
ะธะฝัะธะฝะธัะธะฒ:ัะฟะตัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฟะตัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ัะพะฟะธัั{}, // ัะพะฟะธัั ะฒ ะผะพะปะพะบะต
rus_verbs:ะพัะฒะพะธัั{}, // ะพัะฒะพะธัั ะฒ ัะฐะฑะพัะต
rus_verbs:ะทะฐัะพะดะธัััั{}, // ะทะฐัะพะดะธัััั ะฒ ะณะพะปะพะฒะต
rus_verbs:ะพัะฟะปััั{}, // ะพัะฟะปััั ะฒ ััะฐัะพะน ะปะพะดะบะต
rus_verbs:ะพัััะฐะธะฒะฐัั{}, // ะพัััะฐะธะฒะฐัั ะฒ ััะดะต
rus_verbs:ะพััะถะดะฐัั{}, // ะพััะถะดะฐัั ะฒ ัะฒะพะตะผ ะฒััััะฟะปะตะฝะธะธ
rus_verbs:ะฟะตัะตะณะพะฒะพัะธัั{}, // ะฟะตัะตะณะพะฒะพัะธัั ะฒ ะฟะตัะตััะฒะต
rus_verbs:ัะฐะทะณะพัะฐัััั{}, // ัะฐะทะณะพัะฐัััั ะฒ ัะตัะดัะต
rus_verbs:ัะบัััั{}, // ัะบัััั ะฒ ัะฐะปะฐัะต
rus_verbs:ัะพะผะธัััั{}, // ัะพะผะธัััั ะฒ ะทะฐััะตะฝะบะฐั
rus_verbs:ะบะปัะฑะธัััั{}, // ะบะปัะฑะธัััั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ัะถะธะณะฐัั{}, // ัะถะธะณะฐัั ะฒ ัะพะฟะบะต
rus_verbs:ะฟะพะทะฐะฒััะฐะบะฐัั{}, // ะฟะพะทะฐะฒััะฐะบะฐัั ะฒ ะบะฐัะตัะบะต
rus_verbs:ััะฝะบัะธะพะฝะธัะพะฒะฐัั{}, // ััะฝะบัะธะพะฝะธัะพะฒะฐัั ะฒ ะปะฐะฑะพัะฐัะพัะฝัั
ััะปะพะฒะธัั
rus_verbs:ัะผััั{}, // ัะผััั ะฒ ััะบะต
rus_verbs:ัะฐะทะผะตััะธัั{}, // ัะฐะทะผะตััะธัั ะฒ ะธะฝัะตัะฝะตัะต
rus_verbs:ะฟัะพะฝะตััะธ{}, // ะฟัะพะฝะตััะธ ะฒ ะฟะพัะฐะนะฝะพะผ ะบะฐัะผะฐะฝะต
rus_verbs:ััะบะพะฒะพะดััะฒะพะฒะฐัััั{}, // ััะบะพะฒะพะดััะฒะพะฒะฐัััั ะฒ ัะฐะฑะพัะต
rus_verbs:ะฝะฐัะฐัะธัั{}, // ะฝะฐัะฐัะธัั ะฒ ะฟะพัะตะผะบะฐั
rus_verbs:ะทะฐะบัััะธัั{}, // ะทะฐะบัััะธัั ะฒ ะฒะธั
ัะต
rus_verbs:ะฟัะพัะผะฐััะธะฒะฐัััั{}, // ะฟัะพัะผะฐััะธะฒะฐัััั ะฒ ะดะฐะปัะฝะตะน ะฟะตััะฟะตะบัะธะฒะต
rus_verbs:ัะฐัะฟะพะทะฝะฐัั{}, // ัะฐัะฟะพะทะฝะฐัั ะฒ ะฝะตะทะฝะฐะบะพะผัะต
rus_verbs:ะฟะพะฒะตัะธัััั{}, // ะฟะพะฒะตัะธัััั ะฒ ะบะฐะผะตัะต
rus_verbs:ะพะฑัะฐัะธัั{}, // ะพะฑัะฐัะธัั ะฒ ะฟะพะธัะบะฐั
ะฝะฐัะบะพัะธะบะพะฒ
rus_verbs:ะฝะฐะฟะพะปะฝััััั{}, // ะฝะฐะฟะพะปะฝัะตััั ะฒ ะบะฐััะตัะต
rus_verbs:ะทะฐัะฒะธััะตัั{}, // ะทะฐัะฒะธััะตัั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ะฟัะพัะฒะตัะฐัั{}, // ะฟัะพัะฒะตัะฐัั ะฒ ะผัะณะบะพะผ ะบะปะธะผะฐัะต
rus_verbs:ััััะฐัั{}, // ััััะฐัั ะฒ ะฟัะพััะตะฝะบะต
rus_verbs:ะฟะพะดั
ะฒะฐััะฒะฐัั{}, // ะฟะพะดั
ะฒะฐััะฒะฐัั ะฒ ะฟะพะปะตัะต
ะธะฝัะธะฝะธัะธะฒ:ัะพะธัััั{}, ะณะปะฐะณะพะป:ัะพะธัััั{}, // ัะพะธัััั ะฒ ะฒะพะทะดัั
ะต
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะพะธะฒัะธะนัั{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะพััะธะนัั{},
// ะดะตะตะฟัะธัะฐััะธะต:ัะพััั{ aux stress="ัะพ^ััั" },
rus_verbs:ะฟัะตะพะฑะปะฐะดะฐัั{}, // ะฟัะตะพะฑะปะฐะดะฐัั ะฒ ัะตะบััะต
rus_verbs:ะฟะพัะฒะตัะปะตัั{}, // ะฟะพัะฒะตัะปะตัั ะฒ ะปะธัะต
rus_verbs:ะธะณะฝะพัะธัะพะฒะฐัั{}, // ะธะณะฝะพัะธัะพะฒะฐัั ะฒ ัะตะบะพะผะตะฝะดะฐัะธัั
rus_verbs:ะพะฑััะถะดะฐัััั{}, // ะพะฑััะถะดะฐัััั ะฒ ะบัะปัะฐัะฐั
rus_verbs:ะพัะบะฐะทัะฒะฐัั{}, // ะพัะบะฐะทัะฒะฐัั ะฒ ะฒะธะทะต
rus_verbs:ะพััะฟัะฒะฐัั{}, // ะพััะฟัะฒะฐัั ะฒ ะบะฐัะผะฐะฝะต
rus_verbs:ัะฐะทะปะธะฒะฐัััั{}, // ัะฐะทะปะธะฒะฐัััั ะฒ ัะตั
ั
rus_verbs:ัะฐัะฟะธัะฐัััั{}, // ัะฐัะฟะธัะฐัััั ะฒ ะฟะพะปััะตะฝะธะธ
rus_verbs:ััะธะฝะธัั{}, // ััะธะฝะธัั ะฒ ะบะฐะทะฐัะผะต
rus_verbs:ะฟะปะตััะธัั{}, // ะฟะปะตััะธัั ะฒ ั
ะฒะพััะต
rus_verbs:ะพะฑััะฒะปััััั{}, // ะพะฑััะฒะปััััั ะฒ ะณััะฟะฟะต
rus_verbs:ะฟะพะฒััะฐัััั{}, // ะฟะพะฒััะฐัััั ะฒ ะฟะตัะฒะพะน ัะฐััะธ
rus_verbs:ะฝะฐะฟััะณะฐัั{}, // ะฝะฐะฟััะณะฐัั ะฒ ะฟะฐั
ั
rus_verbs:ัะฐะทัะฐะฑะฐััะฒะฐัั{}, // ัะฐะทัะฐะฑะฐััะฒะฐัั ะฒ ัััะดะธะธ
rus_verbs:ั
ะปะพะฟะพัะฐัั{}, // ั
ะปะพะฟะพัะฐัั ะฒ ะผััะธะธ
rus_verbs:ะฟัะตััะฒะฐัั{}, // ะฟัะตััะฒะฐัั ะฒ ัะฐะผะพะผ ะฝะฐัะฐะปะต
rus_verbs:ะบะฐััััั{}, // ะบะฐััััั ะฒ ะณัะตั
ะฐั
rus_verbs:ะพัะฒะพะธัััั{}, // ะพัะฒะพะธัััั ะฒ ะบะฐะฑะธะฝะต
rus_verbs:ะฟะพะดะฟะปััั{}, // ะฟะพะดะฟะปััั ะฒ ะปะพะดะบะต
rus_verbs:ะทะฐะผะธะณะฐัั{}, // ะทะฐะผะธะณะฐัั ะฒ ัะตะผะฝะพัะต
rus_verbs:ะพัะบะพัะฑะปััั{}, // ะพัะบะพัะฑะปััั ะฒ ะฒััััะฟะปะตะฝะธะธ
rus_verbs:ัะพัะถะตััะฒะพะฒะฐัั{}, // ัะพัะถะตััะฒะพะฒะฐัั ะฒ ะดััะต
rus_verbs:ะฟะพะฟัะฐะฒะปััั{}, // ะฟะพะฟัะฐะฒะปััั ะฒ ะฟัะพะปะพะณะต
rus_verbs:ัะณะฐะดัะฒะฐัั{}, // ัะณะฐะดัะฒะฐัั ะฒ ัะฐะทะผััะพะผ ะธะทะพะฑัะฐะถะตะฝะธะธ
rus_verbs:ะฟะพัะพะฟัะฐัััั{}, // ะฟะพัะพะฟัะฐัััั ะฒ ะฟัะธั
ะพะถะตะน
rus_verbs:ะฟะตัะตะฟัะฐะฒะธัััั{}, // ะฟะตัะตะฟัะฐะฒะธัััั ะฒ ะปะพะดะพัะบะต
rus_verbs:ัะฒะตัะธัััั{}, // ัะฒะตัะธัััั ะฒ ะฝะตะฒะธะฝะพะฒะฝะพััะธ
rus_verbs:ะทะฐะฑัะตะทะถะธัั{}, // ะทะฐะฑัะตะทะถะธัั ะฒ ะบะพะฝัะต ัะพะฝะฝะตะปั
rus_verbs:ััะฒะตัะดะธัััั{}, // ััะฒะตัะดะธัััั ะฒะพ ะผะฝะตะฝะธะธ
rus_verbs:ะทะฐะฒัะฒะฐัั{}, // ะทะฐะฒัะฒะฐัั ะฒ ัััะฑะต
rus_verbs:ะทะฐะฒะฐัะธัั{}, // ะทะฐะฒะฐัะธัั ะฒ ะทะฐะฒะฐัะฝะธะบะต
rus_verbs:ัะบะพะผะบะฐัั{}, // ัะบะพะผะบะฐัั ะฒ ััะบะต
rus_verbs:ะฟะตัะตะผะตัะฐัััั{}, // ะฟะตัะตะผะตัะฐัััั ะฒ ะบะฐะฟััะปะต
ะธะฝัะธะฝะธัะธะฒ:ะฟะธัะฐัััั{ aux stress="ะฟะธั^ะฐัััั" }, ะณะปะฐะณะพะป:ะฟะธัะฐัััั{ aux stress="ะฟะธั^ะฐัััั" }, // ะฟะธัะฐัััั ะฒ ะฟะตัะฒะพะผ ะฟะพะปะต
rus_verbs:ะฟัะฐะทะดะฝะพะฒะฐัั{}, // ะฟัะฐะทะดะฝะพะฒะฐัั ะฒ ะฑะฐัะต
rus_verbs:ะผะธะณะฐัั{}, // ะผะธะณะฐัั ะฒ ัะตะผะฝะพัะต
rus_verbs:ะพะฑััะธัั{}, // ะพะฑััะธัั ะฒ ะผะฐััะตััะบะพะน
rus_verbs:ะพััะดะพะฒะฐัั{}, // ะพััะดะพะฒะฐัั ะฒ ะบะปะฐะดะพะฒะบะต
rus_verbs:ัะฟะพัััะฒะพะฒะฐัั{}, // ัะฟะพัััะฒะพะฒะฐัั ะฒ ะทะฐะฑะปัะถะดะตะฝะธะธ
rus_verbs:ะฟะตัะตะผะธะฝะฐัััั{}, // ะฟะตัะตะผะธะฝะฐัััั ะฒ ะฟัะธั
ะพะถะตะน
rus_verbs:ะฟะพะดัะฐััะธ{}, // ะฟะพะดัะฐััะธ ะฒ ัะตะฟะปะธัะต
rus_verbs:ะฟัะตะดะฟะธััะฒะฐัััั{}, // ะฟัะตะดะฟะธััะฒะฐัััั ะฒ ะทะฐะบะพะฝะต
rus_verbs:ะฟัะธะฟะธัะฐัั{}, // ะฟัะธะฟะธัะฐัั ะฒ ะบะพะฝัะต
rus_verbs:ะทะฐะดะฐะฒะฐัััั{}, // ะทะฐะดะฐะฒะฐัััั ะฒ ัะฒะพะตะน ััะฐััะต
rus_verbs:ัะธะฝะธัั{}, // ัะธะฝะธัั ะฒ ะดะพะผะฐัะฝะธั
ััะปะพะฒะธัั
rus_verbs:ัะฐะทะดะตะฒะฐัััั{}, // ัะฐะทะดะตะฒะฐัััั ะฒ ะฟะปัะถะฝะพะน ะบะฐะฑะธะฝะบะต
rus_verbs:ะฟะพะพะฑะตะดะฐัั{}, // ะฟะพะพะฑะตะดะฐัั ะฒ ัะตััะพัะฐะฝัะธะบะต
rus_verbs:ะถัะฐัั{}, // ะถัะฐัั ะฒ ััะปะฐะฝัะธะบะต
rus_verbs:ะธัะฟะพะปะฝััััั{}, // ะธัะฟะพะปะฝััััั ะฒ ะฐะฝััะฐะบัะต
rus_verbs:ะณะฝะธัั{}, // ะณะฝะธัั ะฒ ััััะผะต
rus_verbs:ะณะปะพะดะฐัั{}, // ะณะปะพะดะฐัั ะฒ ะบะพะฝััะต
rus_verbs:ะฟัะพัะปััะฐัั{}, // ะฟัะพัะปััะฐัั ะฒ ะดะพัะพะณะต
rus_verbs:ะธัััะฐัะธัั{}, // ะธัััะฐัะธัั ะฒ ะบะฐะฑะฐะบะต
rus_verbs:ััะฐัะตัั{}, // ััะฐัะตัั ะฒ ะพะดะธะฝะพัะตััะฒะต
rus_verbs:ัะฐะทะถะตัั{}, // ัะฐะทะถะตัั ะฒ ัะตัะดัะต
rus_verbs:ัะพะฒะตัะฐัััั{}, // ัะพะฒะตัะฐัััั ะฒ ะบะฐะฑะธะฝะตัะต
rus_verbs:ะฟะพะบะฐัะธะฒะฐัั{}, // ะฟะพะบะฐัะธะฒะฐัั ะฒ ะบัะพะฒะฐัะบะต
rus_verbs:ะพััะธะดะตัั{}, // ะพััะธะดะตัั ะฒ ะพะดะธะฝะพัะบะต
rus_verbs:ัะพัะผะธัะพะฒะฐัั{}, // ัะพัะผะธัะพะฒะฐัั ะฒ ัะผะฐั
rus_verbs:ะทะฐั
ัะฐะฟะตัั{}, // ะทะฐั
ัะฐะฟะตัั ะฒะพ ัะฝะต
rus_verbs:ะฟะตัััั{}, // ะฟะตัััั ะฒ ั
ะพัะต
rus_verbs:ะพะฑัะตั
ะฐัั{}, // ะพะฑัะตั
ะฐัั ะฒ ะฐะฒัะพะฑััะต
rus_verbs:ะฟะพัะตะปะธัั{}, // ะฟะพัะตะปะธัั ะฒ ะณะพััะธะฝะธัะต
rus_verbs:ะฟัะตะดะฐัััั{}, // ะฟัะตะดะฐัััั ะฒ ะบะฝะธะณะต
rus_verbs:ะทะฐะฒะพัะพัะฐัััั{}, // ะทะฐะฒะพัะพัะฐัััั ะฒะพ ัะฝะต
rus_verbs:ะฝะฐะฟัััะฐัั{}, // ะฝะฐะฟัััะฐัั ะฒ ะบะฐัะผะฐะฝะฐั
rus_verbs:ะพััั
ะฐัััั{}, // ะพััั
ะฐัััั ะฒ ะฝะตะทะฝะฐะบะพะผะพะผ ะผะตััะต
rus_verbs:ะพะณัะฐะฝะธัะธะฒะฐัั{}, // ะพะณัะฐะฝะธัะธะฒะฐัั ะฒ ะดะฒะธะถะตะฝะธัั
rus_verbs:ะทะฐะฒะตััะตัั{}, // ะทะฐะฒะตััะตัั ะฒ ััะบะฐั
rus_verbs:ะฟะตัะฐัะฐัั{}, // ะฟะตัะฐัะฐัั ะฒ ัะตะดะฐะบัะพัะต
rus_verbs:ัะตะฟะปะธัััั{}, // ัะตะฟะปะธัััั ะฒ ัะตัะดัะต
rus_verbs:ัะฒัะทะฝััั{}, // ัะฒัะทะฝััั ะฒ ะทัะฑััะตะผ ะฟะตัะบะต
rus_verbs:ััะผะพััะตัั{}, // ััะผะพััะตัั ะฒ ะพะฑัะฐัะตะฝะธะธ
rus_verbs:ะพัััะบะฐัััั{}, // ะพัััะบะฐัััั ะฒ ะทะฐะฟะฐัะฐั
rus_verbs:ะฟะพัััะธัั{}, // ะฟะพัััะธัั ะฒ ะณะพัะปะต ะพะณะพะฝั
rus_verbs:ะฟะพัะฑะฐะฒะธัััั{}, // ะฟะพัะฑะฐะฒะธัััั ะฒ ัะฐะทะผะตัะต
rus_verbs:ะทะฐัะธะบัะธัะพะฒะฐัั{}, // ะทะฐัะธะบัะธัะพะฒะฐัั ะฒ ะฟะพััะพัะฝะฝะพะน ะฟะฐะผััะธ
rus_verbs:ัะผััั{}, // ัะผััั ะฒ ะฒะฐะฝะฝะพะน
rus_verbs:ะทะฐะผะตััะธัั{}, // ะทะฐะผะตััะธัั ะฒ ะบัะตัะปะต
rus_verbs:ัะณะฐัะฐัั{}, // ัะณะฐัะฐัั ะฒ ะพะดะธะฝะพัะตััะฒะต
rus_verbs:ััะฐะทะธัั{}, // ััะฐะทะธัั ะฒ ัะฟะพัะต
rus_verbs:ัะธะณััะธัะพะฒะฐัั{}, // ัะธะณััะธัะพะฒะฐัั ะฒ ะฑัะปะปะตัะตะฝะต
rus_verbs:ัะฐัะฟะปัะฒะฐัััั{}, // ัะฐัะฟะปัะฒะฐัััั ะฒ ะณะปะฐะทะฐั
rus_verbs:ัะพััะธัะฐัั{}, // ัะพััะธัะฐัั ะฒ ัะผะต
rus_verbs:ัะณัััะธัััั{}, // ัะณัััะธัััั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ัะธัะธัะพะฒะฐัั{}, // ัะธัะธัะพะฒะฐัั ะฒ ัะฒะพะตะน ััะฐััะต
rus_verbs:ะฟะพะผััััั{}, // ะฟะพะผััััั ะฒ ะดะฐะฒะบะต
rus_verbs:ะทะฐััะฐะณะธะฒะฐัั{}, // ะทะฐััะฐะณะธะฒะฐัั ะฒ ะฟัะพัะตััะต ะฒัะฟะพะปะฝะตะฝะธั
rus_verbs:ะพะฑัะตัะตัั{}, // ะพะฑัะตัะตัั ะฒ ะณะฐัะฐะถะต
rus_verbs:ะฟะพะดัััะตะปะธัั{}, // ะฟะพะดัััะตะปะธัั ะฒ ะฟะพะนะผะต ัะตะบะธ
rus_verbs:ัะฐััะตัะตัั{}, // ัะฐััะตัะตัั ะฒ ััะบะต
rus_verbs:ะฟะพะดะฐะฒะปััั{}, // ะฟะพะดะฐะฒะปััั ะฒ ะทะฐัะพะดััะต
rus_verbs:ัะผะตัะธะฒะฐัััั{}, // ัะผะตัะธะฒะฐัััั ะฒ ัะฐะฝะต
ะธะฝัะธะฝะธัะธะฒ:ะฒััะธัะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฒััะธัะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ะฒััะธัะฐัั ะฒ ะบะฝะธะถะตัะบะต
rus_verbs:ัะพะบัะฐัะธัััั{}, // ัะพะบัะฐัะธัััั ะฒ ะพะฑั
ะฒะฐัะต
rus_verbs:ะทะฐะฝะตัะฒะฝะธัะฐัั{}, // ะทะฐะฝะตัะฒะฝะธัะฐัั ะฒ ะบะฐะฑะธะฝะตัะต
rus_verbs:ัะพะฟัะธะบะพัะฝััััั{}, // ัะพะฟัะธะบะพัะฝััััั ะฒ ะฟะพะปะตัะต
rus_verbs:ะพะฑะพะทะฝะฐัะธัั{}, // ะพะฑะพะทะฝะฐัะธัั ะฒ ะพะฑััะฒะปะตะฝะธะธ
rus_verbs:ะพะฑััะฐัััั{}, // ะพะฑััะฐัััั ะฒ ััะธะปะธัะต
rus_verbs:ัะฝะธะทะธัััั{}, // ัะฝะธะทะธัััั ะฒ ะฝะธะถะฝะธั
ัะปะพัั
ะฐัะผะพััะตัั
rus_verbs:ะปะตะปะตััั{}, // ะปะตะปะตััั ะฒ ัะตัะดัะต
rus_verbs:ะฟะพะดะดะตัะถะธะฒะฐัััั{}, // ะฟะพะดะดะตัะถะธะฒะฐัััั ะฒ ััะดะต
rus_verbs:ัะฟะปััั{}, // ัะฟะปััั ะฒ ะปะพะดะพัะบะต
rus_verbs:ัะตะทะฒะธัััั{}, // ัะตะทะฒะธัััั ะฒ ัะฐะดั
rus_verbs:ะฟะพะตัะทะฐัั{}, // ะฟะพะตัะทะฐัั ะฒ ะณะฐะผะฐะบะต
rus_verbs:ะพะฟะปะฐัะธัั{}, // ะพะฟะปะฐัะธัั ะฒ ัะตััะพัะฐะฝะต
rus_verbs:ะฟะพั
ะฒะฐััะฐัััั{}, // ะฟะพั
ะฒะฐััะฐัััั ะฒ ะบะพะผะฟะฐะฝะธะธ
rus_verbs:ะทะฝะฐะบะพะผะธัััั{}, // ะทะฝะฐะบะพะผะธัััั ะฒ ะบะปะฐััะต
rus_verbs:ะฟัะธะฟะปััั{}, // ะฟัะธะฟะปััั ะฒ ะฟะพะดะฒะพะดะฝะพะน ะปะพะดะบะต
rus_verbs:ะทะฐะถะธะณะฐัั{}, // ะทะฐะถะธะณะฐัั ะฒ ะบะปะฐััะต
rus_verbs:ัะผััะปะธัั{}, // ัะผััะปะธัั ะฒ ะผะฐัะตะผะฐัะธะบะต
rus_verbs:ะทะฐะบะพะฟะฐัั{}, // ะทะฐะบะพะฟะฐัั ะฒ ะพะณะพัะพะดะต
rus_verbs:ะฟะพัั
ะฐัั{}, // ะฟะพัั
ะฐัั ะฒ ะทะฐัะพัะปัั
rus_verbs:ะฟะพัะพะฝััั{}, // ะฟะพัะพะฝััั ะฒ ะฑัะผะฐะถะบะฐั
rus_verbs:ััะธัะฐัั{}, // ััะธัะฐัั ะฒ ั
ะพะปะพะดะฝะพะน ะฒะพะดะต
rus_verbs:ะฟะพะดััะตัะตะณะฐัั{}, // ะฟะพะดััะตัะตะณะฐัั ะฒ ะฟัะธะดะพัะพะถะฝัั
ะบัััะฐั
rus_verbs:ะฟะพะณัะปััั{}, // ะฟะพะณัะปััั ะฒ ะฟะฐัะบะต
rus_verbs:ะฟัะตะดะฒะบััะฐัั{}, // ะฟัะตะดะฒะบััะฐัั ะฒ ะฒะพะพะฑัะฐะถะตะฝะธะธ
rus_verbs:ะพัะตะปะพะผะธัั{}, // ะพัะตะปะพะผะธัั ะฒ ะฑะพั
rus_verbs:ัะดะพััะพะฒะตัะธัััั{}, // ัะดะพััะพะฒะตัะธัััั ะฒ ะฑะตะทะพะฟะฐัะฝะพััะธ
rus_verbs:ะพะณะปะฐัะธัั{}, // ะพะณะปะฐัะธัั ะฒ ะทะฐะบะปััะธัะตะปัะฝะพะน ัะฐััะธ
rus_verbs:ัะฐะทะฑะพะณะฐัะตัั{}, // ัะฐะทะฑะพะณะฐัะตัั ะฒ ะดะตัะตะฒะฝะต
rus_verbs:ะณัะพั
ะพัะฐัั{}, // ะณัะพั
ะพัะฐัั ะฒ ะผะฐััะตััะบะพะน
rus_verbs:ัะตะฐะปะธะทะพะฒะฐัััั{}, // ัะตะฐะปะธะทะพะฒะฐัััั ะฒ ะดะพะปะถะฝะพััะธ
rus_verbs:ะบัะฐััั{}, // ะบัะฐััั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะฝะฐัะฒะฐัััั{}, // ะฝะฐัะฒะฐัััั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ะทะฐัััะฒะฐัั{}, // ะทะฐัััะฒะฐัั ะฒ ะฝะตัะดะพะฑะฝะพะน ะฟะพะทะต
rus_verbs:ัะพะปะบะฐัััั{}, // ัะพะปะบะฐัััั ะฒ ัะตัะฝะพะน ะบะพะผะฝะฐัะต
rus_verbs:ะธะทะฒะปะตะบะฐัั{}, // ะธะทะฒะปะตะบะฐัั ะฒ ะฐะฟะฟะฐัะฐัะต
rus_verbs:ะพะฑะถะธะณะฐัั{}, // ะพะฑะถะธะณะฐัั ะฒ ะฟะตัะธ
rus_verbs:ะทะฐะฟะตัะฐัะปะตัั{}, // ะทะฐะฟะตัะฐัะปะตัั ะฒ ะบะธะฝะพั
ัะพะฝะธะบะต
rus_verbs:ััะตะฝะธัะพะฒะฐัััั{}, // ััะตะฝะธัะพะฒะฐัััั ะฒ ะทะฐะปะต
rus_verbs:ะฟะพัะฟะพัะธัั{}, // ะฟะพัะฟะพัะธัั ะฒ ะบะฐะฑะธะฝะตัะต
rus_verbs:ัััะบะฐัั{}, // ัััะบะฐัั ะฒ ะปะตัั
rus_verbs:ะฝะฐะดััะฒะฐัััั{}, // ะฝะฐะดััะฒะฐัััั ะฒ ัะฐั
ัะต
rus_verbs:ัะฝััััั{}, // ัะฝััััั ะฒ ัะธะปัะผะต
rus_verbs:ะทะฐะบััะถะธัั{}, // ะทะฐะบััะถะธัั ะฒ ัะฐะฝัะต
rus_verbs:ะทะฐัะพะฝััั{}, // ะทะฐัะพะฝััั ะฒ ะฟะพััั
rus_verbs:ะฟะพะฑััั{}, // ะฟะพะฑััั ะฒ ะณะพัััั
rus_verbs:ะฟะพัะธััะธัั{}, // ะฟะพัะธััะธัั ะฒ ะฝะพัั
rus_verbs:ัะณะพัะฑะธัััั{}, // ัะณะพัะฑะธัััั ะฒ ัะตัะฝะพะน ะบะพะฝััะต
rus_verbs:ะฟะพะดัะปััะธะฒะฐัั{}, // ะฟะพะดัะปััะธะฒะฐัั ะฒ ะบะปะฐััะต
rus_verbs:ัะณะพัะฐัั{}, // ัะณะพัะฐัั ะฒ ัะฐะฝะบะต
rus_verbs:ัะฐะทะพัะฐัะพะฒะฐัััั{}, // ัะฐะทะพัะฐัะพะฒะฐัััั ะฒ ะฐััะธััะต
ะธะฝัะธะฝะธัะธะฒ:ะฟะพะฟะธัะฐัั{ aux stress="ะฟะพะฟ^ะธัะฐัั" }, ะณะปะฐะณะพะป:ะฟะพะฟะธัะฐัั{ aux stress="ะฟะพะฟ^ะธัะฐัั" }, // ะฟะพะฟะธัะฐัั ะฒ ะบัััะธะบะฐั
rus_verbs:ะผััั{}, // ะผััั ะฒ ััะบะฐั
rus_verbs:ะฟะพะดัะฐัััั{}, // ะฟะพะดัะฐัััั ะฒ ะบะปะฐััะต
rus_verbs:ะทะฐะผะตััะธ{}, // ะทะฐะผะตััะธ ะฒ ะฟัะธั
ะพะถะตะน
rus_verbs:ะพัะบะปะฐะดัะฒะฐัััั{}, // ะพัะบะปะฐะดัะฒะฐัััั ะฒ ะฟะตัะตะฝะธ
rus_verbs:ะพะฑะพะทะฝะฐัะฐัััั{}, // ะพะฑะพะทะฝะฐัะฐัััั ะฒ ะฟะตัะตัะฝะต
rus_verbs:ะฟัะพัะธะถะธะฒะฐัั{}, // ะฟัะพัะธะถะธะฒะฐัั ะฒ ะธะฝัะตัะฝะตัะต
rus_verbs:ัะพะฟัะธะบะฐัะฐัััั{}, // ัะพะฟัะธะบะฐัะฐัััั ะฒ ัะพัะบะต
rus_verbs:ะฝะฐัะตััะธัั{}, // ะฝะฐัะตััะธัั ะฒ ัะตััะฐะดะบะต
rus_verbs:ัะผะตะฝััะฐัั{}, // ัะผะตะฝััะฐัั ะฒ ะฟะพะฟะตัะตัะฝะธะบะต
rus_verbs:ัะพัะผะพะทะธัั{}, // ัะพัะผะพะทะธัั ะฒ ะพะฑะปะฐะบะต
rus_verbs:ะทะฐัะตะฒะฐัั{}, // ะทะฐัะตะฒะฐัั ะฒ ะปะฐะฑะพัะฐัะพัะธะธ
rus_verbs:ะทะฐัะพะฟะธัั{}, // ะทะฐัะพะฟะธัั ะฒ ะฑัั
ัะต
rus_verbs:ะทะฐะดะตัะถะธะฒะฐัั{}, // ะทะฐะดะตัะถะธะฒะฐัั ะฒ ะปะธััะต
rus_verbs:ะฟัะพะณัะปััััั{}, // ะฟัะพะณัะปััััั ะฒ ะปะตัั
rus_verbs:ะฟัะพััะฑะธัั{}, // ะฟัะพััะฑะธัั ะฒะพ ะปัะดั
rus_verbs:ะพัะธัะฐัั{}, // ะพัะธัะฐัั ะฒ ะบะธัะปะพัะต
rus_verbs:ะฟะพะปัะปะตะถะฐัั{}, // ะฟะพะปัะปะตะถะฐัั ะฒ ะณะฐะผะฐะบะต
rus_verbs:ะธัะฟัะฐะฒะธัั{}, // ะธัะฟัะฐะฒะธัั ะฒ ะทะฐะดะฐะฝะธะธ
rus_verbs:ะฟัะตะดััะผะฐััะธะฒะฐัััั{}, // ะฟัะตะดััะผะฐััะธะฒะฐัััั ะฒ ะฟะพััะฐะฝะพะฒะบะต ะทะฐะดะฐัะธ
rus_verbs:ะทะฐะผััะธัั{}, // ะทะฐะผััะธัั ะฒ ะฟะปะตะฝั
rus_verbs:ัะฐะทัััะฐัััั{}, // ัะฐะทัััะฐัััั ะฒ ะฒะตัั
ะฝะตะน ัะฐััะธ
rus_verbs:ะตัะทะฐัั{}, // ะตัะทะฐัั ะฒ ะบัะตัะปะต
rus_verbs:ะฟะพะบะพะฟะฐัััั{}, // ะฟะพะบะพะฟะฐัััั ะฒ ะทะฐะปะตะถะฐั
rus_verbs:ัะฐัะบะฐััััั{}, // ัะฐัะบะฐััััั ะฒ ัะพะดะตัะฝะฝะพะผ
rus_verbs:ะฟัะพะฑะตะถะฐัััั{}, // ะฟัะพะฑะตะถะฐัััั ะฒ ะฟะฐัะบะต
rus_verbs:ะฟะพะปะตะถะฐัั{}, // ะฟะพะปะตะถะฐัั ะฒ ะณะฐะผะฐะบะต
rus_verbs:ะฟะพะทะฐะธะผััะฒะพะฒะฐัั{}, // ะฟะพะทะฐะธะผััะฒะพะฒะฐัั ะฒ ะบะฝะธะณะต
rus_verbs:ัะฝะธะถะฐัั{}, // ัะฝะธะถะฐัั ะฒ ะฝะตัะบะพะปัะบะพ ัะฐะท
rus_verbs:ัะตัะฟะฐัั{}, // ัะตัะฟะฐัั ะฒ ะฟะพัะทะธะธ
rus_verbs:ะทะฐะฒะตัััั{}, // ะทะฐะฒะตัััั ะฒ ัะฒะพะตะน ะธัะบัะตะฝะฝะพััะธ
rus_verbs:ะฟัะพะณะปัะดะตัั{}, // ะฟัะพะณะปัะดะตัั ะฒ ััะผะตัะบะฐั
rus_verbs:ะฟัะธะฟะฐัะบะพะฒะฐัั{}, // ะฟัะธะฟะฐัะบะพะฒะฐัั ะฒะพ ะดะฒะพัะต
rus_verbs:ัะฒะตัะปะธัั{}, // ัะฒะตัะปะธัั ะฒ ััะตะฝะต
rus_verbs:ะทะดะพัะพะฒะฐัััั{}, // ะทะดะพัะพะฒะฐัััั ะฒ ะฐัะดะธัะพัะธะธ
rus_verbs:ัะพะถะฐัั{}, // ัะพะถะฐัั ะฒ ะฒะพะดะต
rus_verbs:ะฝะฐัะฐัะฐะฟะฐัั{}, // ะฝะฐัะฐัะฐะฟะฐัั ะฒ ัะตััะฐะดะบะต
rus_verbs:ะทะฐัะพะฟะฐัั{}, // ะทะฐัะพะฟะฐัั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ะฟัะพะฟะธัะฐัั{}, // ะฟัะพะฟะธัะฐัั ะฒ ะฟัะฐะฒะธะปะฐั
rus_verbs:ัะพัะธะตะฝัะธัะพะฒะฐัััั{}, // ัะพัะธะตะฝัะธัะพะฒะฐัััั ะฒ ะพะฑััะพััะตะปัััะฒะฐั
rus_verbs:ัะฝะธะทะธัั{}, // ัะฝะธะทะธัั ะฒ ะฝะตัะบะพะปัะบะพ ัะฐะท
rus_verbs:ะทะฐะฑะปัะถะดะฐัััั{}, // ะทะฐะฑะปัะถะดะฐัััั ะฒ ัะฒะพะตะน ัะตะพัะธะธ
rus_verbs:ะพัะบะพะฟะฐัั{}, // ะพัะบะพะฟะฐัั ะฒ ะพัะฒะฐะปะฐั
rus_verbs:ัะผะฐััะตัะธัั{}, // ัะผะฐััะตัะธัั ะฒ ะปะฐะฑะพัะฐัะพัะธะธ
rus_verbs:ะทะฐะผะตะดะปะธัััั{}, // ะทะฐะผะตะดะปะธัััั ะฒ ะฟะฐัะฐัะธะฝะต
rus_verbs:ะธะทะฑะธะฒะฐัั{}, // ะธะทะฑะธะฒะฐัั ะฒ ััะฐััะบะต
rus_verbs:ะผััััั{}, // ะผััััั ะฒ ะฑะฐะฝะต
rus_verbs:ัะฒะฐัะธัั{}, // ัะฒะฐัะธัั ะฒ ะบะฐััััะปัะบะต
rus_verbs:ัะฐัะบะพะฟะฐัั{}, // ัะฐัะบะพะฟะฐัั ะฒ ัะฝะตะณั
rus_verbs:ะบัะตะฟะธัััั{}, // ะบัะตะฟะธัััั ะฒ ะดะตัะถะฐัะตะปะต
rus_verbs:ะดัะพะฑะธัั{}, // ะดัะพะฑะธัั ะฒ ะผะตะปัะฝะธัะต
rus_verbs:ะฟะพะฟะธัั{}, // ะฟะพะฟะธัั ะฒ ัะตััะพัะฐะฝัะธะบะต
rus_verbs:ะทะฐััะพะฝััั{}, // ะทะฐััะพะฝััั ะฒ ะดััะต
rus_verbs:ะปัะทะณะฝััั{}, // ะปัะทะณะฝััั ะฒ ัะธัะธะฝะต
rus_verbs:ะทะฐะฟัะฐะฒะปััั{}, // ะทะฐะฟัะฐะฒะปััั ะฒ ะฟะพะปะตัะต
rus_verbs:ัะฐะทะผะฝะพะถะฐัััั{}, // ัะฐะทะผะฝะพะถะฐัััั ะฒ ะฝะตะฒะพะปะต
rus_verbs:ะฟะพัะพะฟะธัั{}, // ะฟะพัะพะฟะธัั ะฒ ะขะธั
ะพะผ ะะบะตะฐะฝะต
rus_verbs:ะบััะฐัั{}, // ะบััะฐัั ะฒ ััะพะปะพะฒะพะน
rus_verbs:ะทะฐะผะพะปะบะฐัั{}, // ะทะฐะผะพะปะบะฐัั ะฒ ะทะฐะผะตัะฐัะตะปัััะฒะต
rus_verbs:ะธะทะผะตัััััั{}, // ะธะทะผะตัััััั ะฒ ะดัะนะผะฐั
rus_verbs:ัะฑัะฒะฐัััั{}, // ัะฑัะฒะฐัััั ะฒ ะผะตััะฐั
rus_verbs:ะทะฐะดะตัะฝััั{}, // ะทะฐะดะตัะฝััั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ะทะฐัะธั
ะฐัั{}, // ะทะฐัะธั
ะฐัั ะฒ ัะตะผะฝะพัะต
rus_verbs:ะฟัะพัะปะตะถะธะฒะฐัััั{}, // ะฟัะพัะปะตะถะธะฒะฐะตััั ะฒ ะถััะฝะฐะปะต
rus_verbs:ะฟัะตััะฒะฐัััั{}, // ะฟัะตััะฒะฐะตััั ะฒ ะฝะฐัะฐะปะต
rus_verbs:ะธะทะพะฑัะฐะถะฐัััั{}, // ะธะทะพะฑัะฐะถะฐะตััั ะฒ ะปัะฑัั
ัะธะปัะผะฐั
rus_verbs:ัะธะบัะธัะพะฒะฐัั{}, // ัะธะบัะธัะพะฒะฐัั ะฒ ะดะฐะฝะฝะพะน ัะพัะบะต
rus_verbs:ะพัะปะฐะฑะปััั{}, // ะพัะปะฐะฑะปััั ะฒ ะฟะพััะต
rus_verbs:ะทัะตัั{}, // ะทัะตัั ะฒ ัะตะฟะปะธัะต
rus_verbs:ะทะตะปะตะฝะตัั{}, // ะทะตะปะตะฝะตัั ะฒ ะพะณะพัะพะดะต
rus_verbs:ะบัะธัะธะบะพะฒะฐัั{}, // ะบัะธัะธะบะพะฒะฐัั ะฒ ััะฐััะต
rus_verbs:ะพะฑะปะตัะตัั{}, // ะพะฑะปะตัะตัั ะฒ ัะฐััะฝะพะผ ะฒะตััะพะปะตัะต
rus_verbs:ัะฐะทะฑัะพัะฐัั{}, // ัะฐะทะฑัะพัะฐัั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ะทะฐัะฐะทะธัััั{}, // ะทะฐัะฐะทะธัััั ะฒ ะปัะดะฝะพะผ ะผะตััะต
rus_verbs:ัะฐััะตััั{}, // ัะฐััะตััั ะฒ ะฑะพั
rus_verbs:ะฟะตัััั{}, // ะฟะตัััั ะฒ ะดัั
ะพะฒะบะต
rus_verbs:ะฟะพัะฟะฐัั{}, // ะฟะพัะฟะฐัั ะฒ ะฟะฐะปะฐัะบะต
rus_verbs:ะทะฐัััะฟะธัััั{}, // ะทะฐัััะฟะธัััั ะฒ ะดัะฐะบะต
rus_verbs:ัะฟะปะตัะฐัััั{}, // ัะฟะปะตัะฐัััั ะฒ ัะตัะตะดะธะฝะต
rus_verbs:ะฟะพะผะตััะธัััั{}, // ะฟะพะผะตััะธัััั ะฒ ะผะตัะบะต
rus_verbs:ัะฟะตัะตัั{}, // ัะฟะตัะตัั ะฒ ะปะฐะฒะบะต
// ะธะฝัะธะฝะธัะธะฒ:ะปะธะบะฒะธะดะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะปะธะบะฒะธะดะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะปะธะบะฒะธะดะธัะพะฒะฐัั ะฒ ะฟัะธะณะพัะพะดะต
// ะธะฝัะธะฝะธัะธะฒ:ะปะธะบะฒะธะดะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะปะธะบะฒะธะดะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
rus_verbs:ะฟัะพะฒะฐะปััััั{}, // ะฟัะพะฒะฐะปััััั ะฒ ะฟะพััะตะปะธ
rus_verbs:ะปะตัะธัััั{}, // ะปะตัะธัััั ะฒ ััะฐัะธะพะฝะฐัะต
rus_verbs:ะพะฟัะตะดะตะปะธัััั{}, // ะพะฟัะตะดะตะปะธัััั ะฒ ัะตััะฝะพะผ ะฑะพั
rus_verbs:ะพะฑัะฐะฑะพัะฐัั{}, // ะพะฑัะฐะฑะพัะฐัั ะฒ ัะฐััะฒะพัะต
rus_verbs:ะฟัะพะฑะธะฒะฐัั{}, // ะฟัะพะฑะธะฒะฐัั ะฒ ััะตะฝะต
rus_verbs:ะฟะตัะตะผะตัะฐัััั{}, // ะฟะตัะตะผะตัะฐัััั ะฒ ัะฐะฝะต
rus_verbs:ัะตัะฐัั{}, // ัะตัะฐัั ะฒ ะฟะฐั
ั
rus_verbs:ะฟัะพะปะตัั{}, // ะฟัะพะปะตัั ะฒ ะฟััััะฝะฝะพะน ะผะตััะฝะพััะธ
rus_verbs:ัะบะธัะฐัััั{}, // ัะบะธัะฐัััั ะฒ ะดะฐะปัะฝะธั
ัััะฐะฝะฐั
rus_verbs:ะทะฐัััะดะฝััััั{}, // ะทะฐัััะดะฝััััั ะฒ ะฒัะฑะพัะต
rus_verbs:ะพัััั
ะฝััััั{}, // ะพัััั
ะฝััััั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ัะฐะทัะณััะฒะฐัััั{}, // ัะฐะทัะณััะฒะฐัััั ะฒ ะปะพัะตัะตะต
rus_verbs:ะฟะพะผะพะปะธัััั{}, // ะฟะพะผะพะปะธัััั ะฒ ัะตัะบะฒะธ
rus_verbs:ะฟัะตะดะฟะธััะฒะฐัั{}, // ะฟัะตะดะฟะธััะฒะฐัั ะฒ ัะตัะตะฟัะต
rus_verbs:ะฟะพัะฒะฐัััั{}, // ะฟะพัะฒะฐัััั ะฒ ัะปะฐะฑะพะผ ะผะตััะต
rus_verbs:ะณัะตัััั{}, // ะณัะตัััั ะฒ ะทะดะฐะฝะธะธ
rus_verbs:ะพะฟัะพะฒะตัะณะฐัั{}, // ะพะฟัะพะฒะตัะณะฐัั ะฒ ัะฒะพะตะผ ะฒััััะฟะปะตะฝะธะธ
rus_verbs:ะฟะพะผัะฝััั{}, // ะฟะพะผัะฝััั ะฒ ัะฒะพะตะผ ะฒััััะฟะปะตะฝะธะธ
rus_verbs:ะดะพะฟัะพัะธัั{}, // ะดะพะฟัะพัะธัั ะฒ ะฟัะพะบััะฐัััะต
rus_verbs:ะผะฐัะตัะธะฐะปะธะทะพะฒะฐัััั{}, // ะผะฐัะตัะธะฐะปะธะทะพะฒะฐัััั ะฒ ัะพัะตะดะฝะตะผ ะทะดะฐะฝะธะธ
rus_verbs:ัะฐััะตะธะฒะฐัััั{}, // ัะฐััะตะธะฒะฐัััั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ะฟะตัะตะฒะพะทะธัั{}, // ะฟะตัะตะฒะพะทะธัั ะฒ ะฒะฐะณะพะฝะต
rus_verbs:ะพัะฑัะฒะฐัั{}, // ะพัะฑัะฒะฐัั ะฒ ััััะผะต
rus_verbs:ะฟะพะฟะฐั
ะธะฒะฐัั{}, // ะฟะพะฟะฐั
ะธะฒะฐัั ะฒ ะพัั
ะพะถะตะผ ะผะตััะต
rus_verbs:ะฟะตัะตัะธัะปััั{}, // ะฟะตัะตัะธัะปััั ะฒ ะทะฐะบะปััะตะฝะธะธ
rus_verbs:ะทะฐัะพะถะดะฐัััั{}, // ะทะฐัะพะถะดะฐัััั ะฒ ะดะตะฑััั
rus_verbs:ะฟัะตะดััะฒะปััั{}, // ะฟัะตะดััะฒะปััั ะฒ ัะฒะพะตะผ ะฟะธััะผะต
rus_verbs:ัะฐัะฟัะพัััะฐะฝััั{}, // ัะฐัะฟัะพัััะฐะฝััั ะฒ ัะตัะธ
rus_verbs:ะฟะธัะพะฒะฐัั{}, // ะฟะธัะพะฒะฐัั ะฒ ัะพัะตะดะฝะตะผ ัะตะปะต
rus_verbs:ะฝะฐัะตััะฐัั{}, // ะฝะฐัะตััะฐัั ะฒ ะปะตัะพะฟะธัะธ
rus_verbs:ัะฐััะฒะตัะฐัั{}, // ัะฐััะฒะตัะฐัั ะฒ ะฟะพะดั
ะพะดััะธั
ััะปะพะฒะธัั
rus_verbs:ัะฐัััะฒะพะฒะฐัั{}, // ัะฐัััะฒะพะฒะฐัั ะฒ ัะถะฝะพะน ัะฐััะธ ะผะฐัะตัะธะบะฐ
rus_verbs:ะฝะฐะบะพะฟะธัั{}, // ะฝะฐะบะพะฟะธัั ะฒ ะฑััะตัะต
rus_verbs:ะทะฐะบัััะธัััั{}, // ะทะฐะบัััะธัััั ะฒ ัััะธะฝะต
rus_verbs:ะพััะฐะฑะพัะฐัั{}, // ะพััะฐะฑะพัะฐัั ะฒ ะทะฐะฑะพะต
rus_verbs:ะพะฑะพะบัะฐััั{}, // ะพะฑะพะบัะฐััั ะฒ ะฐะฒัะพะฑััะต
rus_verbs:ะฟัะพะบะปะฐะดัะฒะฐัั{}, // ะฟัะพะบะปะฐะดัะฒะฐัั ะฒ ัะฝะตะณั
rus_verbs:ะบะพะฒััััั{}, // ะบะพะฒััััั ะฒ ะฝะพัั
rus_verbs:ะบะพะฟะธัั{}, // ะบะพะฟะธัั ะฒ ะพัะตัะตะดะธ
rus_verbs:ะฟะพะปะตัั{}, // ะฟะพะปะตัั ะฒ ััะตะฟัั
rus_verbs:ัะตะฑะตัะฐัั{}, // ัะตะฑะตัะฐัั ะฒ ะบัััะธะบะฐั
rus_verbs:ะฟะพะดัะตัะบะธะฒะฐัััั{}, // ะฟะพะดัะตัะบะธะฒะฐัััั ะฒ ัะพะพะฑัะตะฝะธะธ
rus_verbs:ะฟะพัะตััั{}, // ะฟะพัะตััั ะฒ ะพะณะพัะพะดะต
rus_verbs:ัะฐะทัะตะทะถะฐัั{}, // ัะฐะทัะตะทะถะฐัั ะฒ ะบะฐะฑัะธะพะปะตัะต
rus_verbs:ะทะฐะผะตัะฐัััั{}, // ะทะฐะผะตัะฐัััั ะฒ ะปะตัั
rus_verbs:ะฟัะพััะธัะฐัั{}, // ะฟัะพััะธัะฐัั ะฒ ัะผะต
rus_verbs:ะผะฐััััั{}, // ะผะฐััััั ะฒ ะบะพะผะฐะฝะดะธัะพะฒะบะต
rus_verbs:ะฒัั
ะฒะฐััะฒะฐัั{}, // ะฒัั
ะฒะฐััะฒะฐัั ะฒ ัะตะบััะต
rus_verbs:ะบัะตััะธัััั{}, // ะบัะตััะธัััั ะฒ ะดะตัะตะฒะตะฝัะบะพะน ัะฐัะพะฒะฝะต
rus_verbs:ะพะฑัะฐะฑะฐััะฒะฐัั{}, // ะพะฑัะฐะฑะฐััะฒะฐัั ะฒ ัะฐััะฒะพัะต ะบะธัะปะพัั
rus_verbs:ะฝะฐััะธะณะฐัั{}, // ะฝะฐััะธะณะฐัั ะฒ ะพะณะพัะพะดะต
rus_verbs:ัะฐะทะณัะปะธะฒะฐัั{}, // ัะฐะทะณัะปะธะฒะฐัั ะฒ ัะพัะต
rus_verbs:ะฝะฐัะธะปะพะฒะฐัั{}, // ะฝะฐัะธะปะพะฒะฐัั ะฒ ะบะฒะฐััะธัะต
rus_verbs:ะฟะพะฑะพัะพัั{}, // ะฟะพะฑะพัะพัั ะฒ ัะตะฑะต
rus_verbs:ััะธััะฒะฐัั{}, // ััะธััะฒะฐัั ะฒ ัะฐััะตัะฐั
rus_verbs:ะธัะบะฐะถะฐัั{}, // ะธัะบะฐะถะฐัั ะฒ ะทะฐะผะตัะบะต
rus_verbs:ะฟัะพะฟะธัั{}, // ะฟัะพะฟะธัั ะฒ ะบะฐะฑะฐะบะต
rus_verbs:ะบะฐัะฐัั{}, // ะบะฐัะฐัั ะฒ ะปะพะดะพัะบะต
rus_verbs:ะฟัะธะฟัััะฐัั{}, // ะฟัะธะฟัััะฐัั ะฒ ะบะฐัะผะฐัะบะต
rus_verbs:ะทะฐะฟะฐะฝะธะบะพะฒะฐัั{}, // ะทะฐะฟะฐะฝะธะบะพะฒะฐัั ะฒ ะฑะพั
rus_verbs:ัะฐัััะฟะฐัั{}, // ัะฐัััะฟะฐัั ะฒ ััะฐะฒะต
rus_verbs:ะทะฐัััะตะฒะฐัั{}, // ะทะฐัััะตะฒะฐัั ะฒ ะพะณัะฐะดะต
rus_verbs:ะทะฐะถะธะณะฐัััั{}, // ะทะฐะถะธะณะฐัััั ะฒ ััะผะตัะบะฐั
rus_verbs:ะถะฐัะธัั{}, // ะถะฐัะธัั ะฒ ะผะฐัะปะต
rus_verbs:ะฝะฐะบะฐะฟะปะธะฒะฐัััั{}, // ะฝะฐะบะฐะฟะปะธะฒะฐัััั ะฒ ะบะพัััั
rus_verbs:ัะฐัะฟัััะธัััั{}, // ัะฐัะฟัััะธัััั ะฒ ะณะพััะบะต
rus_verbs:ะฟัะพะณะพะปะพัะพะฒะฐัั{}, // ะฟัะพะณะพะปะพัะพะฒะฐัั ะฒ ะฟะตัะตะดะฒะธะถะฝะพะผ ะฟัะฝะบัะต
rus_verbs:ัััะฐะฝััะฒะพะฒะฐัั{}, // ัััะฐะฝััะฒะพะฒะฐัั ะฒ ะฐะฒัะพะผะพะฑะธะปะต
rus_verbs:ะพัะผะฐััะธะฒะฐัััั{}, // ะพัะผะฐััะธะฒะฐัััั ะฒ ั
ะพัะพะผะฐั
rus_verbs:ัะฐะทะฒะพัะฐัะธะฒะฐัั{}, // ัะฐะทะฒะพัะฐัะธะฒะฐัั ะฒ ัะฟะพััะทะฐะปะต
rus_verbs:ะทะฐัะบััะฐัั{}, // ะทะฐัะบััะฐัั ะฒ ัะฐะผะพะปะตัะต
rus_verbs:ะฝะฐะฟััะฐัั{}, // ะฝะฐะฟััะฐัั ะฒ ัะฐััะตัะต
rus_verbs:ะฟะตัะตะบััะธัั{}, // ะฟะตัะตะบััะธัั ะฒ ััะพะปะพะฒะพะน
rus_verbs:ัะฟะฐัะฐัััั{}, // ัะฟะฐัะฐัััั ะฒ ะฐะฒัะพะฝะพะผะฝะพะน ะบะฐะฟััะปะต
rus_verbs:ะฟะพัะพะฒะตัะฐัััั{}, // ะฟะพัะพะฒะตัะฐัััั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ะดะพะบะฐะทัะฒะฐัััั{}, // ะดะพะบะฐะทัะฒะฐัััั ะฒ ััะฐััะต
rus_verbs:ะฟะพะทะฝะฐะฒะฐัััั{}, // ะฟะพะทะฝะฐะฒะฐัััั ะฒ ะฑะตะดะต
rus_verbs:ะทะฐะณััััะธัั{}, // ะทะฐะณััััะธัั ะฒ ะพะดะธะฝะพัะตััะฒะต
rus_verbs:ะพะถะธะฒะธัั{}, // ะพะถะธะฒะธัั ะฒ ะฟะฐะผััะธ
rus_verbs:ะฟะตัะตะฒะพัะฐัะธะฒะฐัััั{}, // ะฟะตัะตะฒะพัะฐัะธะฒะฐัััั ะฒ ะณัะพะฑั
rus_verbs:ะทะฐะฟัะธะผะตัะธัั{}, // ะทะฐะฟัะธะผะตัะธัั ะฒ ะปะตัั
rus_verbs:ะพััะฐะฒะธัััั{}, // ะพััะฐะฒะธัััั ะฒ ะทะฐะฑะตะณะฐะปะพะฒะบะต
rus_verbs:ะฟัะพะดะตัะถะฐัั{}, // ะฟัะพะดะตัะถะฐัั ะฒ ะบะปะตัะบะต
rus_verbs:ะฒััะฒะธัั{}, // ะฒััะฒะธัั ะฒ ะบะพัััั
rus_verbs:ะทะฐัะตะดะฐัั{}, // ะทะฐัะตะดะฐัั ะฒ ัะพะฒะตัะต
rus_verbs:ัะฐัะฟะปะฐัะธะฒะฐัััั{}, // ัะฐัะฟะปะฐัะธะฒะฐัััั ะฒ ะฟะตัะฒะพะน ะบะฐััะต
rus_verbs:ะฟัะพะปะพะผะธัั{}, // ะฟัะพะปะพะผะธัั ะฒ ะดะฒะตัะธ
rus_verbs:ะฟะพะดัะฐะถะฐัั{}, // ะฟะพะดัะฐะถะฐัั ะฒ ะผะตะปะพัะฐั
rus_verbs:ะฟะพะดััะธััะฒะฐัั{}, // ะฟะพะดััะธััะฒะฐัั ะฒ ัะผะต
rus_verbs:ะพะฟะตัะตะถะฐัั{}, // ะพะฟะตัะตะถะฐัั ะฒะพ ะฒัะตะผ
rus_verbs:ััะพัะผะธัะพะฒะฐัััั{}, // ััะพัะผะธัะพะฒะฐัััั ะฒ ะพะฑะปะฐะบะต
rus_verbs:ัะบัะตะฟะธัััั{}, // ัะบัะตะฟะธัััั ะฒ ะผะฝะตะฝะธะธ
rus_verbs:ะพัััะพััั{}, // ะพัััะพััั ะฒ ะพัะตัะตะดะธ
rus_verbs:ัะฐะทะฒะตัััะฒะฐัััั{}, // ัะฐะทะฒะตัััะฒะฐัััั ะฒ ะผะตััะต ะธัะฟััะฐะฝะธั
rus_verbs:ะทะฐะผะตัะทะฐัั{}, // ะทะฐะผะตัะทะฐัั ะฒะพ ะปัะดั
rus_verbs:ััะพะฟะฐัั{}, // ััะพะฟะฐัั ะฒ ัะฝะตะณั
rus_verbs:ัะฐัะบะฐะธะฒะฐัััั{}, // ัะฐัะบะฐะธะฒะฐัััั ะฒ ัะพะดะตัะฝะฝะพะผ
rus_verbs:ะพัะณะฐะฝะธะทะพะฒัะฒะฐัั{}, // ะพัะณะฐะฝะธะทะพะฒัะฒะฐัั ะฒ ะฟะธะพะฝะตัะปะฐะณะตัะต
rus_verbs:ะฟะตัะตะฒะตััะธัั{}, // ะฟะตัะตะฒะตััะธัั ะฒ ะฝะฐัะธั
ะบัะฐัั
rus_verbs:ัะผะตัะธะฒะฐัั{}, // ัะผะตัะธะฒะฐัั ะฒ ะฑะปะตะฝะดะตัะต
rus_verbs:ััะธัััั{}, // ััะธัััั ะฒ ัะตัะฝะพะน ะบะฐะผะพัะบะต
rus_verbs:ะฟัะพะถะดะฐัั{}, // ะฟัะพะถะดะฐัั ะฒ ะฐัะดะธัะพัะธะธ
rus_verbs:ะฟะพะดััะบะธะฒะฐัั{}, // ะฟะพะดััะบะธะฒะฐัั ะฒ ะถะตะฝัะบะพะผ ะพะฑัะตะถะธัะธะธ
rus_verbs:ะทะฐะผะพัะธัั{}, // ะทะฐะผะพัะธัั ะฒ ัะพััะธัะต
rus_verbs:ะผะตัะทะฝััั{}, // ะผะตัะทะฝััั ะฒ ัะพะฝะบะพะน ะบัััะพัะบะต
rus_verbs:ัะฐััะธัะฐัั{}, // ัะฐััะธัะฐัั ะฒ ัััะฟะบะต
rus_verbs:ะทะฐะผะตะดะปััั{}, // ะทะฐะผะตะดะปััั ะฒ ะฟะฐัะฐัะธะฝะต
rus_verbs:ะฟะตัะตัะฟะฐัั{}, // ะฟะตัะตัะฟะฐัั ะฒ ะฟะฐะปะฐัะบะต
rus_verbs:ัะฐััะตะบะฐัั{}, // ัะฐััะตะบะฐัั ะฒ ะบะฐะฑัะธะพะปะตัะต
rus_verbs:ะพัััะบะธะฒะฐัั{}, // ะพัััะบะธะฒะฐัั ะฒ ะทะฐะปะตะถะฐั
rus_verbs:ะพะฟัะพะฒะตัะณะฝััั{}, // ะพะฟัะพะฒะตัะณะฝััั ะฒ ัะฒะพะตะผ ะฒััััะฟะปะตะฝะธะธ
rus_verbs:ะดััั
ะฝััั{}, // ะดััั
ะฝััั ะฒ ะณะฐะผะฐะบะต
rus_verbs:ัะบััะฒะฐัััั{}, // ัะบััะฒะฐัััั ะฒ ะทะตะผะปัะฝะบะต
rus_verbs:ะทะฐะฟะตัััั{}, // ะทะฐะฟะตัััั ะฒ ะทะพะปะต
rus_verbs:ะดะพะณะพัะฐัั{}, // ะดะพะณะพัะฐัั ะฒ ัะตะผะฝะพัะต
rus_verbs:ะทะฐััะธะปะฐัั{}, // ะทะฐััะธะปะฐัั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ัััะบะฐัััั{}, // ัััะบะฐัััั ะฒ ะดะตัะตะฒะฝะต
rus_verbs:ะฟะตัะตะดะตะปะฐัั{}, // ะฟะตัะตะดะตะปะฐัั ะฒ ะผะฐััะตััะบะพะน
rus_verbs:ัะฐะทัััะฝััั{}, // ัะฐะทัััะฝััั ะฒ ัะฒะพะตะน ะปะตะบัะธะธ
rus_verbs:ัะตะปะธัััั{}, // ัะตะปะธัััั ะฒ ัะตะฝััะต
rus_verbs:ะพะฟะปะฐัะธะฒะฐัั{}, // ะพะฟะปะฐัะธะฒะฐัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะฟะตัะตะฒะพัะฐัะธะฒะฐัั{}, // ะฟะตัะตะฒะพัะฐัะธะฒะฐัั ะฒ ะทะฐะบัััะพะน ะฑะฐะฝะบะต
rus_verbs:ัะฟัะฐะถะฝััััั{}, // ัะฟัะฐะถะฝััััั ะฒ ะพัััะพัะผะธะธ
rus_verbs:ะฟะพะผะตัะธัั{}, // ะฟะพะผะตัะธัั ะฒ ัะฟะธัะบะต
rus_verbs:ะฟัะธะฟะพะผะฝะธัััั{}, // ะฟัะธะฟะพะผะฝะธัััั ะฒ ะทะฐะฒะตัะฐะฝะธะธ
rus_verbs:ะฟัะธััะธัั{}, // ะฟัะธััะธัั ะฒ ะฐะผะฑะฐัะต
rus_verbs:ะฝะฐัะตัะฟะตัััั{}, // ะฝะฐัะตัะฟะตัััั ะฒ ัะตะผะฝะธัะต
rus_verbs:ะทะฐัะตะฒะฐัััั{}, // ะทะฐัะตะฒะฐัััั ะฒ ะบะปัะฑะต
rus_verbs:ัะฟะปัะฒะฐัั{}, // ัะฟะปัะฒะฐัั ะฒ ะปะพะดะบะต
rus_verbs:ัะบะธัะฝััั{}, // ัะบะธัะฝััั ะฒ ะฑะธะดะพะฝะต
rus_verbs:ะทะฐะบะพะปะพัั{}, // ะทะฐะบะพะปะพัั ะฒ ะฑะพะบั
rus_verbs:ะทะฐะผะตััะฐัั{}, // ะทะฐะผะตััะฐัั ะฒ ัะตะผะฝะพัะต
rus_verbs:ัะธะบัะธัะพะฒะฐัััั{}, // ัะธะบัะธัะพะฒะฐัััั ะฒ ะฟัะพัะพะบะพะปะต
rus_verbs:ะทะฐะฟะธัะฐัััั{}, // ะทะฐะฟะธัะฐัััั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ััะตะทะถะฐัััั{}, // ััะตะทะถะฐัััั ะฒ ะบะฐัะตัะฐั
rus_verbs:ัะพะปะพัััั{}, // ัะพะปะพัััั ะฒ ัััะฟะต
rus_verbs:ะฟะพัะฐะฝัะตะฒะฐัั{}, // ะฟะพัะฐะฝัะตะฒะฐัั ะฒ ะบะปัะฑะต
rus_verbs:ะฟะพะฑัะพะดะธัั{}, // ะฟะพะฑัะพะดะธัั ะฒ ะฟะฐัะบะต
rus_verbs:ะฝะฐะทัะตะฒะฐัั{}, // ะฝะฐะทัะตะฒะฐัั ะฒ ะบะพะปะปะตะบัะธะฒะต
rus_verbs:ะดะพั
ะฝััั{}, // ะดะพั
ะฝััั ะฒ ะฟะธัะพะผะฝะธะบะต
rus_verbs:ะบัะตััะธัั{}, // ะบัะตััะธัั ะฒ ะดะตัะตะฒะตะฝัะบะพะน ัะตัะบะฒััะบะต
rus_verbs:ัะฐัััะธัะฐัััั{}, // ัะฐัััะธัะฐัััั ะฒ ะฑะฐะฝะบะต
rus_verbs:ะฟัะธะฟะฐัะบะพะฒะฐัััั{}, // ะฟัะธะฟะฐัะบะพะฒะฐัััั ะฒะพ ะดะฒะพัะต
rus_verbs:ะพัั
ะฒะฐัะธัั{}, // ะพัั
ะฒะฐัะธัั ะฒ ะผะฐะณะฐะทะธะฝัะธะบะต
rus_verbs:ะพัััะฒะฐัั{}, // ะพัััะฒะฐัั ะฒ ั
ะพะปะพะดะธะปัะฝะธะบะต
rus_verbs:ัะพััะฐะฒะปััััั{}, // ัะพััะฐะฒะปััััั ะฒ ะฐัะผะพััะตัะต ัะฐะนะฝั
rus_verbs:ะฟะตัะตะฒะฐัะธะฒะฐัั{}, // ะฟะตัะตะฒะฐัะธะฒะฐัั ะฒ ัะธัะธะฝะต
rus_verbs:ั
ะฒะฐััะฐัั{}, // ั
ะฒะฐััะฐัั ะฒ ะบะฐะทะธะฝะพ
rus_verbs:ะพััะฐะฑะฐััะฒะฐัั{}, // ะพััะฐะฑะฐััะฒะฐัั ะฒ ัะตะฟะปะธัะต
rus_verbs:ัะฐะทะปะตัััั{}, // ัะฐะทะปะตัััั ะฒ ะบัะพะฒะฐัะธ
rus_verbs:ะฟัะพะบัััะธะฒะฐัั{}, // ะฟัะพะบัััะธะฒะฐัั ะฒ ะณะพะปะพะฒะต
rus_verbs:ะพัะตััะธัั{}, // ะพัะตััะธัั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ัะบะพะฝััะทะธัััั{}, // ัะบะพะฝััะทะธัััั ะฒ ะพะบััะถะตะฝะธะธ ะฝะตะทะฝะฐะบะพะผัั
ะปัะดะตะน
rus_verbs:ะฒััะฒะปััั{}, // ะฒััะฒะปััั ะฒ ะฑะพะตะฒัั
ััะปะพะฒะธัั
rus_verbs:ะบะฐัะฐัะปะธัั{}, // ะบะฐัะฐัะปะธัั ะฒ ะปะธััะต
rus_verbs:ัะฐัััะฐะฒะปััั{}, // ัะฐัััะฐะฒะปััั ะฒ ะฑะพะนะฝะธัะฐั
rus_verbs:ะฟัะพะบัััะธัั{}, // ะฟัะพะบัััะธัั ะฒ ะณะพะปะพะฒะต
rus_verbs:ะฟะตัะตัะบะฐะทัะฒะฐัั{}, // ะฟะตัะตัะบะฐะทัะฒะฐัั ะฒ ะฟะตัะฒะพะน ะณะปะฐะฒะต
rus_verbs:ะทะฐะดะฐะฒะธัั{}, // ะทะฐะดะฐะฒะธัั ะฒ ะทะฐัะพะดััะต
rus_verbs:ั
ะพะทัะนะฝะธัะฐัั{}, // ั
ะพะทัะนะฝะธัะฐัั ะฒ ั
ะพะปะพะดะธะปัะฝะธะบะต
rus_verbs:ั
ะฒะฐะปะธัััั{}, // ั
ะฒะฐะปะธัััั ะฒ ะดะตััะบะพะผ ัะฐะดะธะบะต
rus_verbs:ะพะฟะตัะธัะพะฒะฐัั{}, // ะพะฟะตัะธัะพะฒะฐัั ะฒ ะฟะพะปะตะฒะพะผ ะณะพัะฟะธัะฐะปะต
rus_verbs:ัะพัะผัะปะธัะพะฒะฐัั{}, // ัะพัะผัะปะธัะพะฒะฐัั ะฒ ัะปะตะดัััะตะน ะณะปะฐะฒะต
rus_verbs:ะทะฐััะธะณะฝััั{}, // ะทะฐััะธะณะฝััั ะฒ ะฝะตะฟัะธะณะปัะดะฝะพะผ ะฒะธะดะต
rus_verbs:ะทะฐะผััะปัะบะฐัั{}, // ะทะฐะผััะปัะบะฐัั ะฒ ัะตะฟะปะต
rus_verbs:ะฟะพะดะดะฐะบะธะฒะฐัั{}, // ะฟะพะดะดะฐะบะธะฒะฐัั ะฒ ัะฟะพัะต
rus_verbs:ะฟัะพัะตััะธัั{}, // ะฟัะพัะตััะธัั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ะพัะผะตะฝััั{}, // ะพัะผะตะฝััั ะฒ ะณะพัะพะดะต ะบะพะผะตะฝะดะฐะฝัะบะธะน ัะฐั
rus_verbs:ะบะพะปะดะพะฒะฐัั{}, // ะบะพะปะดะพะฒะฐัั ะฒ ะปะฐะฑะพัะฐัะพัะธะธ
rus_verbs:ะพัะฒะพะทะธัั{}, // ะพัะฒะพะทะธัั ะฒ ะผะฐัะธะฝะต
rus_verbs:ััะฐั
ะฐัั{}, // ััะฐั
ะฐัั ะฒ ะณะฐะผะฐะบะต
rus_verbs:ะฟะพะฒะพะทะธัััั{}, // ะฟะพะฒะพะทะธัััั ะฒ ะผะตัะบะต
rus_verbs:ัะตะผะพะฝัะธัะพะฒะฐัั{}, // ัะตะผะพะฝัะธัะพะฒะฐัั ะฒ ัะตะฝััะต
rus_verbs:ัะพะฑะตัั{}, // ัะพะฑะตัั ะฒ ะณะพัััั
rus_verbs:ะฟะตัะตะฟัะพะฑะพะฒะฐัั{}, // ะฟะตัะตะฟัะพะฑะพะฒะฐัั ะฒ ะดะตะปะต
ะธะฝัะธะฝะธัะธะฒ:ัะตะฐะปะธะทะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ัะตะฐะปะธะทะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ัะตะฐะปะธะทะพะฒะฐัั ะฒ ะฝะพะฒะพะน ะฒะตััะธะธ
ะณะปะฐะณะพะป:ัะตะฐะปะธะทะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะตะฐะปะธะทะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ะฟะพะบะฐััััั{}, // ะฟะพะบะฐััััั ะฒ ัะตัะบะฒะธ
rus_verbs:ะฟะพะฟััะณะฐัั{}, // ะฟะพะฟััะณะฐัั ะฒ ะฑะฐััะตะนะฝะต
rus_verbs:ัะผะฐะปัะธะฒะฐัั{}, // ัะผะฐะปัะธะฒะฐัั ะฒ ัะฒะพะตะผ ะดะพะบะปะฐะดะต
rus_verbs:ะบะพะฒััััััั{}, // ะบะพะฒััััััั ะฒ ััะฐัะพะน ัะตั
ะฝะธะบะต
rus_verbs:ัะฐัะฟะธััะฒะฐัั{}, // ัะฐัะฟะธััะฒะฐัั ะฒ ะดะตัะฐะปัั
rus_verbs:ะฒัะทะฝััั{}, // ะฒัะทะฝััั ะฒ ะฟะตัะบะต
rus_verbs:ะฟะพะณััะทะฝััั{}, // ะฟะพะณััะทะฝััั ะฒ ัะบะฐะฝะดะฐะปะฐั
rus_verbs:ะบะพัะตะฝะธัััั{}, // ะบะพัะตะฝะธัััั ะฒ ะฝะตัะฟะพัะพะฑะฝะพััะธ ะฒัะฟะพะปะฝะธัั ะฟะพััะฐะฒะปะตะฝะฝัั ะทะฐะดะฐัั
rus_verbs:ะทะฐะถะธะผะฐัั{}, // ะทะฐะถะธะผะฐัั ะฒ ัะณะปั
rus_verbs:ััะธัะบะธะฒะฐัั{}, // ััะธัะบะธะฒะฐัั ะฒ ะปะฐะดะพะฝัั
rus_verbs:ะฟัะฐะบัะธะบะพะฒะฐัััั{}, // ะฟัะฐะบัะธะบะพะฒะฐัััั ะฒ ะฟัะธะณะพัะพะฒะปะตะฝะธะธ ัะพััะฐ
rus_verbs:ะธะทัะฐัั
ะพะดะพะฒะฐัั{}, // ะธะทัะฐัั
ะพะดะพะฒะฐัั ะฒ ะฟะพะปะตัะต
rus_verbs:ะบะปะพะบะพัะฐัั{}, // ะบะปะพะบะพัะฐัั ะฒ ะถะตัะปะต
rus_verbs:ะพะฑะฒะธะฝััััั{}, // ะพะฑะฒะธะฝััััั ะฒ ัะฐัััะฐัะต
rus_verbs:ัะตะดะธะฝะธัััั{}, // ัะตะดะธะฝะธัััั ะฒ ะบะปะฐะดะพะฒะบะต
rus_verbs:ะฟะพะดะพั
ะฝััั{}, // ะฟะพะดะพั
ะฝััั ะฒ ะฑะพะปะพัะต
rus_verbs:ะบะธะฟััะธัััั{}, // ะบะธะฟััะธัััั ะฒ ัะฐะนะฝะธะบะต
rus_verbs:ััะพะดะธัััั{}, // ััะพะดะธัััั ะฒ ะปะตัั
rus_verbs:ะฟัะพะดะพะปะถะธัััั{}, // ะฟัะพะดะพะปะถะธัััั ะฒ ะฑะฐัะต
rus_verbs:ัะฐััะธััะพะฒะฐัั{}, // ัะฐััะธััะพะฒะฐัั ะฒ ัะฟะตัะธะฐะปัะฝะพะผ ััััะพะนััะฒะต
rus_verbs:ะฟะพัะฐะฟัะฒะฐัั{}, // ะฟะพัะฐะฟัะฒะฐัั ะฒ ะบัะพะฒะฐัะธ
rus_verbs:ัะบัััะธัััั{}, // ัะบัััะธัััั ะฒ ะผะตัะบะต
rus_verbs:ะปััะพะฒะฐัั{}, // ะปััะพะฒะฐัั ะฒ ะพัะดะฐะปะตะฝะฝัั
ัะตะปะฐั
rus_verbs:ัะฐัะฟะธัะฐัั{}, // ัะฐัะฟะธัะฐัั ะฒ ััะฐััะต
rus_verbs:ะฟัะฑะปะธะบะพะฒะฐัััั{}, // ะฟัะฑะปะธะบะพะฒะฐัััั ะฒ ะฝะฐััะฝะพะผ ะถััะฝะฐะปะต
rus_verbs:ะทะฐัะตะณะธัััะธัะพะฒะฐัั{}, // ะทะฐัะตะณะธัััะธัะพะฒะฐัั ะฒ ะบะพะผะธัะตัะต
rus_verbs:ะฟัะพะถะตัั{}, // ะฟัะพะถะตัั ะฒ ะปะธััะต
rus_verbs:ะฟะตัะตะถะดะฐัั{}, // ะฟะตัะตะถะดะฐัั ะฒ ะพะบะพะฟะต
rus_verbs:ะฟัะฑะปะธะบะพะฒะฐัั{}, // ะฟัะฑะปะธะบะพะฒะฐัั ะฒ ะถััะฝะฐะปะต
rus_verbs:ะผะพััะธัั{}, // ะผะพััะธัั ะฒ ัะณะพะปะบะฐั
ะณะปะฐะท
rus_verbs:ัะฟะธัััั{}, // ัะฟะธัััั ะฒ ะพะดะธะฝะพัะตััะฒะต
rus_verbs:ะธะทะฒะตะดะฐัั{}, // ะธะทะฒะตะดะฐัั ะฒ ะณะฐัะตะผะต
rus_verbs:ะพะฑะผะฐะฝััััั{}, // ะพะฑะผะฐะฝััััั ะฒ ะพะถะธะดะฐะฝะธัั
rus_verbs:ัะพัะตัะฐัั{}, // ัะพัะตัะฐัั ะฒ ัะตะฑะต
rus_verbs:ะฟะพะดัะฐะฑะฐััะฒะฐัั{}, // ะฟะพะดัะฐะฑะฐััะฒะฐัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ัะตะฟะตัะธัะพะฒะฐัั{}, // ัะตะฟะตัะธัะพะฒะฐัั ะฒ ัััะดะธะธ
rus_verbs:ััะฑะธัั{}, // ััะฑะธัั ะฒ ะณะปะฐะทะฐั
rus_verbs:ะฝะฐะผะพัะธัั{}, // ะฝะฐะผะพัะธัั ะฒ ะปัะถะต
rus_verbs:ัะบะฐัะฐัั{}, // ัะบะฐัะฐัั ะฒ ััะบะต
rus_verbs:ะพะดะตะฒะฐัั{}, // ะพะดะตะฒะฐัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะธัะฟะตัั{}, // ะธัะฟะตัั ะฒ ะดัั
ะพะฒะบะต
rus_verbs:ัะฑัะธัั{}, // ัะฑัะธัั ะฒ ะฟะพะดะผััะบะฐั
rus_verbs:ะทะฐะถัะถะถะฐัั{}, // ะทะฐะถัะถะถะฐัั ะฒ ัั
ะต
rus_verbs:ัะฑะตัะตัั{}, // ัะฑะตัะตัั ะฒ ัะฐะนะฝะพะผ ะผะตััะต
rus_verbs:ัะพะณัะตัััั{}, // ัะพะณัะตัััั ะฒ ั
ะธะถะธะฝะต
ะธะฝัะธะฝะธัะธะฒ:ะดะตะฑััะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ะดะตะฑััะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ะดะตะฑััะธัะพะฒะฐัั ะฒ ัะฟะตะบัะฐะบะปะต
ะณะปะฐะณะพะป:ะดะตะฑััะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะดะตะฑััะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
rus_verbs:ะฟะตัะตะฟะปััั{}, // ะฟะตัะตะฟะปััั ะฒ ะปะพะดะพัะบะต
rus_verbs:ะฟะตัะตะดะพั
ะฝััั{}, // ะฟะตัะตะดะพั
ะฝััั ะฒ ัะตะฝะธ
rus_verbs:ะพััะฒะตัะธะฒะฐัั{}, // ะพััะฒะตัะธะฒะฐัั ะฒ ะทะตัะบะฐะปะฐั
rus_verbs:ะฟะตัะตะฟัะฐะฒะปััััั{}, // ะฟะตัะตะฟัะฐะฒะปััััั ะฒ ะปะพะดะบะฐั
rus_verbs:ะฝะฐะบัะฟะธัั{}, // ะฝะฐะบัะฟะธัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะฟัะพัะพััะฐัั{}, // ะฟัะพัะพััะฐัั ะฒ ะพัะตัะตะดะธ
rus_verbs:ะฟัะพัะบะฐะปัะทัะฒะฐัั{}, // ะฟัะพัะบะฐะปัะทัะฒะฐัั ะฒ ัะพะพะฑัะตะฝะธัั
rus_verbs:ะทะฐัััะบะฐัั{}, // ะทะฐัััะบะฐัั ะฒ ัะพะปััะธะธ
rus_verbs:ะฝะฐะตััั{}, // ะฝะฐะตััั ะฒ ะพัะฟััะบะต
rus_verbs:ะฟะพะดะฒะธะทะฐัััั{}, // ะฟะพะดะฒะธะทะฐัััั ะฒ ะฝะพะฒะพะผ ะดะตะปะต
rus_verbs:ะฒััะธััะธัั{}, // ะฒััะธััะธัั ะฒ ัะฐะดั
rus_verbs:ะบะพัะผะธัััั{}, // ะบะพัะผะธัััั ะฒ ะปะตัั
rus_verbs:ะฟะพะบััะธัั{}, // ะฟะพะบััะธัั ะฒ ัะฐะดั
rus_verbs:ะฟะพะฝะธะทะธัััั{}, // ะฟะพะฝะธะทะธัััั ะฒ ัะฐะฝะณะต
rus_verbs:ะทะธะผะพะฒะฐัั{}, // ะทะธะผะพะฒะฐัั ะฒ ะธะทะฑััะบะต
rus_verbs:ะฟัะพะฒะตัััััั{}, // ะฟัะพะฒะตัััััั ะฒ ัะปัะถะฑะต ะฑะตะทะพะฟะฐัะฝะพััะธ
rus_verbs:ะฟะพะดะฟะธัะฐัั{}, // ะฟะพะดะฟะธัะฐัั ะฒ ะฟะตัะฒะพะผ ะทะฐะฑะพะต
rus_verbs:ะบัะฒััะบะฐัััั{}, // ะบัะฒััะบะฐัััั ะฒ ะฟะพััะตะปะธ
rus_verbs:ะฟะพั
ัะฐะฟัะฒะฐัั{}, // ะฟะพั
ัะฐะฟัะฒะฐัั ะฒ ะฟะพััะตะปะธ
rus_verbs:ะทะฐะฒัะทะฝััั{}, // ะทะฐะฒัะทะฝััั ะฒ ะฟะตัะบะต
rus_verbs:ััะฐะบัะพะฒะฐัั{}, // ััะฐะบัะพะฒะฐัั ะฒ ะธััะปะตะดะพะฒะฐัะตะปััะบะพะน ััะฐััะต
rus_verbs:ะทะฐะผะตะดะปััััั{}, // ะทะฐะผะตะดะปััััั ะฒ ััะถะตะปะพะน ะฒะพะดะต
rus_verbs:ัะฐััะฐัั{}, // ัะฐััะฐัั ะฒ ะทะดะฐะฝะธะธ
rus_verbs:ะทะฐะฝะพัะตะฒะฐัั{}, // ะทะฐะฝะพัะตะฒะฐัั ะฒ ะฟััะธ
rus_verbs:ะฝะฐะผะตัะธัััั{}, // ะฝะฐะผะตัะธัััั ะฒ ะธััะปะตะดะพะฒะฐะฝะธัั
ัะฐะบะฐ
rus_verbs:ะพัะฒะตะถะธัั{}, // ะพัะฒะตะถะธัั ะฒ ะฟะฐะผััะธ
rus_verbs:ะพัะฟะฐัะธะฒะฐัั{}, // ะพัะฟะฐัะธะฒะฐัั ะฒ ััะดะต
rus_verbs:ัะผะตัะฐัััั{}, // ัะผะตัะฐัััั ะฒ ััะตะนะบะต
rus_verbs:ะธัะบัะฟะธัั{}, // ะธัะบัะฟะธัั ะฒ ะฑะพั
rus_verbs:ะพััะธะถะธะฒะฐัััั{}, // ะพััะธะถะธะฒะฐัััั ะฒ ััะปั
rus_verbs:ะผัะฐัั{}, // ะผัะฐัั ะฒ ะบะฐะฑัะธะพะปะตัะต
rus_verbs:ะพะฑะปะธัะฐัั{}, // ะพะฑะปะธัะฐัั ะฒ ัะฒะพะตะผ ะฒััััะฟะปะตะฝะธะธ
rus_verbs:ัะณะฝะธัั{}, // ัะณะฝะธัั ะฒ ััััะณะต
rus_verbs:ะพะฟัะพะฑะพะฒะฐัั{}, // ะพะฟัะพะฑะพะฒะฐัั ะฒ ะดะตะปะต
rus_verbs:ััะตะฝะธัะพะฒะฐัั{}, // ััะตะฝะธัะพะฒะฐัั ะฒ ะทะฐะปะต
rus_verbs:ะฟัะพัะปะฐะฒะธัั{}, // ะฟัะพัะปะฐะฒะธัั ะฒ ะฐะบะฐะดะตะผะธะธ
rus_verbs:ััะธััะฒะฐัััั{}, // ััะธััะฒะฐัััั ะฒ ะดะธะฟะปะพะผะฝะพะน ัะฐะฑะพัะต
rus_verbs:ะฟะพะฒะตัะตะปะธัััั{}, // ะฟะพะฒะตัะตะปะธัััั ะฒ ะปะฐะณะตัะต
rus_verbs:ะฟะพัะผะฝะตัั{}, // ะฟะพัะผะฝะตัั ะฒ ะบะฐััะตัะต
rus_verbs:ะฟะตัะตัััะตะปััั{}, // ะฟะตัะตัััะตะปััั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ะฟัะพะฒะตะดะฐัั{}, // ะฟัะพะฒะตะดะฐัั ะฒ ะฑะพะปัะฝะธัะต
rus_verbs:ะธะทะผััะธัััั{}, // ะธะทะผััะธัััั ะฒ ะดะตัะตะฒะฝะต
rus_verbs:ะฟัะพััะฟะฐัั{}, // ะฟัะพััะฟะฐัั ะฒ ะณะปัะฑะธะฝะต
rus_verbs:ะธะทะณะพัะพะฒะปััั{}, // ะธะทะณะพัะพะฒะปััั ะฒ ัะฐัะฐะต
rus_verbs:ัะฒะธัะตะฟััะฒะพะฒะฐัั{}, // ัะฒะธัะตะฟััะฒะพะฒะฐัั ะฒ ะฟะพะฟัะปััะธะธ
rus_verbs:ะธัััะบะฐัั{}, // ะธัััะบะฐัั ะฒ ะธััะพัะฝะธะบะต
rus_verbs:ะณะฝะตะทะดะธัััั{}, // ะณะฝะตะทะดะธัััั ะฒ ะดัะฟะปะต
rus_verbs:ัะฐะทะพะณะฝะฐัััั{}, // ัะฐะทะพะณะฝะฐัััั ะฒ ัะฟะพััะธะฒะฝะพะน ะผะฐัะธะฝะต
rus_verbs:ะพะฟะพะทะฝะฐะฒะฐัั{}, // ะพะฟะพะทะฝะฐะฒะฐัั ะฒ ะฝะตะธะทะฒะตััะฝะพะผ
rus_verbs:ะทะฐัะฒะธะดะตัะตะปัััะฒะพะฒะฐัั{}, // ะทะฐัะฒะธะดะตัะตะปัััะฒะพะฒะฐัั ะฒ ััะดะต
rus_verbs:ัะบะพะฝัะตะฝััะธัะพะฒะฐัั{}, // ัะบะพะฝัะตะฝััะธัะพะฒะฐัั ะฒ ัะฒะพะธั
ััะบะฐั
rus_verbs:ัะตะดะฐะบัะธัะพะฒะฐัั{}, // ัะตะดะฐะบัะธัะพะฒะฐัั ะฒ ัะตะดะฐะบัะพัะต
rus_verbs:ะฟะพะบัะฟะฐัััั{}, // ะฟะพะบัะฟะฐัััั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะฟัะพะผััะปััั{}, // ะฟัะพะผััะปััั ะฒ ัะพัะต
rus_verbs:ัะฐัััะณะธะฒะฐัััั{}, // ัะฐัััะณะธะฒะฐัััั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ะฟัะธะพะฑัะตัะฐัััั{}, // ะฟัะธะพะฑัะตัะฐัััั ะฒ ะฐะฝัะธะบะฒะฐัะฝัั
ะปะฐะฒะบะฐั
ะธะฝัะธะฝะธัะธะฒ:ะฟะพะดัะตะทะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ะฟะพะดัะตะทะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ะฟะพะดัะตะทะฐัั ะฒ ะฒะพะดะต
ะณะปะฐะณะพะป:ะฟะพะดัะตะทะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฟะพะดัะตะทะฐัั{ ะฒะธะด:ัะพะฒะตัั },
rus_verbs:ะทะฐะฟะตัะฐัะปะตัััั{}, // ะทะฐะฟะตัะฐัะปะตัััั ะฒ ะผะพะทะณั
rus_verbs:ัะบััะฒะฐัั{}, // ัะบััะฒะฐัั ะฒ ะฟะพะดะฒะฐะปะต
rus_verbs:ะทะฐะบัะตะฟะธัััั{}, // ะทะฐะบัะตะฟะธัััั ะฒ ะฟะตัะฒะพะน ะฑะฐัะฝะต
rus_verbs:ะพัะฒะตะถะฐัั{}, // ะพัะฒะตะถะฐัั ะฒ ะฟะฐะผััะธ
rus_verbs:ะณัะพะผัั
ะฐัั{}, // ะณัะพะผัั
ะฐัั ะฒ ะฒะฐะฝะฝะพะน
ะธะฝัะธะฝะธัะธะฒ:ะฟะพะดะฒะธะณะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ะฟะพะดะฒะธะณะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฟะพะดะฒะธะณะฐัััั ะฒ ะบัะพะฒะฐัะธ
ะณะปะฐะณะพะป:ะฟะพะดะฒะธะณะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฟะพะดะฒะธะณะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ะดะพะฑัะฒะฐัััั{}, // ะดะพะฑัะฒะฐัััั ะฒ ัะฐั
ัะฐั
rus_verbs:ัะฐััะฒะพัะธัั{}, // ัะฐััะฒะพัะธัั ะฒ ะบะธัะปะพัะต
rus_verbs:ะฟัะธะฟะปัััะฒะฐัั{}, // ะฟัะธะฟะปัััะฒะฐัั ะฒ ะณัะธะผะตัะบะต
rus_verbs:ะดะพะถะธะฒะฐัั{}, // ะดะพะถะธะฒะฐัั ะฒ ะดะพะผะต ะฟัะตััะฐัะตะปัั
rus_verbs:ะพัะฟัะฐะทะดะฝะพะฒะฐัั{}, // ะพัะฟัะฐะทะดะฝะพะฒะฐัั ะฒ ัะตััะพัะฐะฝะต
rus_verbs:ัะพััััะฐัััั{}, // ัะพััััะฐัััั ะฒ ะบะพะฝะฒัะปััะธัั
rus_verbs:ะฟะพะผััั{}, // ะฟะพะผััั ะฒ ะฟัะพัะพัะฝะพะน ะฒะพะดะต
ะธะฝัะธะฝะธัะธะฒ:ัะฒัะทะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ัะฒัะทะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะฒัะทะฐัั ะฒ ะฟะตัะบะต
ะณะปะฐะณะพะป:ัะฒัะทะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฒัะทะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฒัะทะฐะฒัะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ะฝะฐะปะธัะตััะฒะพะฒะฐัั{}, // ะฝะฐะปะธัะตััะฒะพะฒะฐัั ะฒ ะทะฐะฟะฐัะฝะธะบะต
rus_verbs:ะฝะฐััะฟัะฒะฐัั{}, // ะฝะฐััะฟัะฒะฐัั ะฒ ะบะฐัะผะฐะฝะต
rus_verbs:ะฟะพะฒะตััะฒะพะฒะฐัััั{}, // ะฟะพะฒะตััะฒะพะฒะฐัััั ะฒ ัะฐััะบะฐะทะต
rus_verbs:ะพััะตะผะพะฝัะธัะพะฒะฐัั{}, // ะพััะตะผะพะฝัะธัะพะฒะฐัั ะฒ ัะตั
ัะตะฝััะต
rus_verbs:ะฟะพะบะฐะปัะฒะฐัั{}, // ะฟะพะบะฐะปัะฒะฐัั ะฒ ะฟัะฐะฒะพะผ ะฑะพะบั
rus_verbs:ัะธะถะธะฒะฐัั{}, // ัะธะถะธะฒะฐัั ะฒ ัะฐะดั
rus_verbs:ัะฐะทัะฐะฑะฐััะฒะฐัััั{}, // ัะฐะทัะฐะฑะฐััะฒะฐัััั ะฒ ัะตะบัะตัะฝัั
ะปะฐะฑะพัะฐัะพัะธัั
rus_verbs:ัะบัะตะฟะปััััั{}, // ัะบัะตะฟะปััััั ะฒ ะผะฝะตะฝะธะธ
rus_verbs:ัะฐะทะฝะธัััั{}, // ัะฐะทะฝะธัััั ะฒะพ ะฒะทะณะปัะดะฐั
rus_verbs:ัะฟะพะปะพัะฝััั{}, // ัะฟะพะปะพัะฝััั ะฒ ะฒะพะดะธัะบะต
rus_verbs:ัะบัะฟะฐัั{}, // ัะบัะฟะฐัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะฟะพัะตััะฒะฐัั{}, // ะฟะพัะตััะฒะฐัั ะฒ ะฟะฐั
ั
rus_verbs:ะพัะพัะผะปััั{}, // ะพัะพัะผะปััั ะฒ ะบะพะฝัะพัะต
rus_verbs:ัะฐัะฟััะบะฐัััั{}, // ัะฐัะฟััะบะฐัััั ะฒ ัะฐะดะฐั
rus_verbs:ะทะฐััะฑะธัั{}, // ะทะฐััะฑะธัั ะฒ ะณะปะฐะทะฐั
rus_verbs:ะทะฐะณะพัะตัั{}, // ะทะฐะณะพัะตัั ะฒ ะัะฟะฐะฝะธะธ
rus_verbs:ะพัะธัะฐัััั{}, // ะพัะธัะฐัััั ะฒ ะฑะฐะบะต
rus_verbs:ะพัััะดะธัั{}, // ะพัััะดะธัั ะฒ ั
ะพะปะพะดะฝะพะน ะฒะพะดะต
rus_verbs:ัะฐะทะฑะพะผะฑะธัั{}, // ัะฐะทะฑะพะผะฑะธัั ะฒ ะณะพัะฐั
rus_verbs:ะธะทะดะพั
ะฝััั{}, // ะธะทะดะพั
ะฝััั ะฒ ะฑะตะดะฝะพััะธ
rus_verbs:ะฟัะพะตั
ะฐัััั{}, // ะฟัะพะตั
ะฐัััั ะฒ ะฝะพะฒะพะน ะผะฐัะธะฝะต
rus_verbs:ะทะฐะดะตะนััะฒะพะฒะฐัั{}, // ะทะฐะดะตะนััะฒะพะฒะฐัั ะฒ ะฐะฝะฐะปะธะทะต
rus_verbs:ะฟัะพะธะทัะฐััะฐัั{}, // ะฟัะพะธะทัะฐััะฐัั ะฒ ััะตะฟะธ
rus_verbs:ัะฐะทััััั{}, // ัะฐะทััััั ะฒ ะฟัะธั
ะพะถะตะน
rus_verbs:ัะพะพััะถะฐัั{}, // ัะพะพััะถะฐัั ะฒ ะพะณะพัะพะดะต
rus_verbs:ะทะฐัะธััะฒะฐัั{}, // ะทะฐัะธััะฒะฐัั ะฒ ััะดะต
rus_verbs:ัะพัััะทะฐัััั{}, // ัะพัััะทะฐัััั ะฒ ะพัััะพัะผะธะธ
rus_verbs:ะพะฟะพะปะพัะฝััั{}, // ะพะฟะพะปะพัะฝััั ะฒ ะผะพะปะพะบะต
rus_verbs:ัะผะตััะธัััั{}, // ัะผะตััะธัััั ะฒ ะบะฐัะผะฐะฝะต
rus_verbs:ัะพะฒะตััะตะฝััะฒะพะฒะฐัััั{}, // ัะพะฒะตััะตะฝััะฒะพะฒะฐัััั ะฒ ัะฟัะฐะฒะปะตะฝะธะธ ะผะพัะพัะธะบะปะพะผ
rus_verbs:ััะธัะฐัััั{}, // ััะธัะฐัััั ะฒ ััะธัะฐะปัะฝะพะน ะผะฐัะธะฝะต
rus_verbs:ะธัะบัะฟะฐัััั{}, // ะธัะบัะฟะฐัััั ะฒ ะฟัะพั
ะปะฐะดะฝะพะน ัะตะบะต
rus_verbs:ะบััะธัะพะฒะฐัั{}, // ะบััะธัะพะฒะฐัั ะฒ ะฟัะฐะฒะธัะตะปัััะฒะต
rus_verbs:ะทะฐะบัะฟะธัั{}, // ะทะฐะบัะฟะธัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะฟะปะพะดะธัััั{}, // ะฟะปะพะดะธัััั ะฒ ะฟะพะดั
ะพะดััะธั
ััะปะพะฒะธัั
rus_verbs:ะณะพัะปะฐะฝะธัั{}, // ะณะพัะปะฐะฝะธัั ะฒ ะฟะฐัะบะต
rus_verbs:ะฟะตััะธัั{}, // ะฟะตััะธัั ะฒ ะณะพัะปะต
rus_verbs:ะฟัะธะณัะตะทะธัััั{}, // ะฟัะธะณัะตะทะธัััั ะฒะพ ัะฝะต
rus_verbs:ะธัะฟัะฐะฒะปััั{}, // ะธัะฟัะฐะฒะปััั ะฒ ัะตััะฐะดะบะต
rus_verbs:ัะฐััะปะฐะฑะปััััั{}, // ัะฐััะปะฐะฑะปััััั ะฒ ะณะฐะผะฐะบะต
rus_verbs:ัะบะฐะฟะปะธะฒะฐัััั{}, // ัะบะฐะฟะปะธะฒะฐัััั ะฒ ะฝะธะถะฝะตะน ัะฐััะธ
rus_verbs:ัะฟะปะตัะฝะธัะฐัั{}, // ัะฟะปะตัะฝะธัะฐัั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ัะฐะทะดะตะฒะฐัั{}, // ัะฐะทะดะตะฒะฐัั ะฒ ะบะฐะฑะธะฝะบะต
rus_verbs:ะพะบะพะฟะฐัััั{}, // ะพะบะพะฟะฐัััั ะฒ ะปะตัั
rus_verbs:ะทะฐะณะพัะฐัั{}, // ะทะฐะณะพัะฐัั ะฒ ะัะฟะฐะฝะธะธ
rus_verbs:ะฟะพะดะฟะตะฒะฐัั{}, // ะฟะพะดะฟะตะฒะฐัั ะฒ ัะตัะบะพะฒะฝะพะผ ั
ะพัะต
rus_verbs:ะฟัะพะถัะถะถะฐัั{}, // ะฟัะพะถัะถะถะฐัั ะฒ ะดะธะฝะฐะผะธะบะต
rus_verbs:ะธะทััะฐัััั{}, // ะธะทััะฐัััั ะฒ ะดะธะบะพะน ะฟัะธัะพะดะต
rus_verbs:ะทะฐะบะปัะฑะธัััั{}, // ะทะฐะบะปัะฑะธัััั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ะฟะพะดะผะตัะฐัั{}, // ะฟะพะดะผะตัะฐัั ะฒ ะทะฐะปะต
rus_verbs:ะฟะพะดะพะทัะตะฒะฐัััั{}, // ะฟะพะดะพะทัะตะฒะฐัััั ะฒ ัะพะฒะตััะตะฝะธะธ ะบัะฐะถะธ
rus_verbs:ะพะฑะพะณะฐัะฐัั{}, // ะพะฑะพะณะฐัะฐัั ะฒ ัะฟะตัะธะฐะปัะฝะพะผ ะฐะฟะฟะฐัะฐัะต
rus_verbs:ะธะทะดะฐัััั{}, // ะธะทะดะฐัััั ะฒ ะดััะณะพะผ ะธะทะดะฐัะตะปัััะฒะต
rus_verbs:ัะฟัะฐะฒะธัั{}, // ัะฟัะฐะฒะธัั ะฒ ะบัััะฐั
ะฝัะถะดั
rus_verbs:ะฟะพะผััััั{}, // ะฟะพะผััััั ะฒ ะฑะฐะฝะต
rus_verbs:ะฟัะพัะบะฐะบะธะฒะฐัั{}, // ะฟัะพัะบะฐะบะธะฒะฐัั ะฒ ัะปะพะฒะฐั
rus_verbs:ะฟะพะฟะธะฒะฐัั{}, // ะฟะพะฟะธะฒะฐัั ะฒ ะบะฐัะต ัะฐะน
rus_verbs:ะพัะพัะผะปััััั{}, // ะพัะพัะผะปััััั ะฒ ัะตะณะธัััะฐัััะต
rus_verbs:ัะธัะธะบะฐัั{}, // ัะธัะธะบะฐัั ะฒ ะบัััะฐั
rus_verbs:ัะบัะฟะธัั{}, // ัะบัะฟะธัั ะฒ ะผะฐะณะฐะทะธะฝะฐั
rus_verbs:ะฟะตัะตะฝะพัะตะฒะฐัั{}, // ะฟะตัะตะฝะพัะตะฒะฐัั ะฒ ะณะพััะธะฝะธัะต
rus_verbs:ะบะพะฝัะตะฝััะธัะพะฒะฐัััั{}, // ะบะพะฝัะตะฝััะธัะพะฒะฐัััั ะฒ ะฟัะพะฑะธัะบะต
rus_verbs:ะพะดะธัะฐัั{}, // ะพะดะธัะฐัั ะฒ ะปะตัั
rus_verbs:ะบะพะฒััะฝััั{}, // ะบะพะฒััะฝััั ะฒ ัั
ะต
rus_verbs:ะทะฐัะตะฟะปะธัััั{}, // ะทะฐัะตะฟะปะธัััั ะฒ ะณะปัะฑะธะฝะต ะดััะธ
rus_verbs:ัะฐะทะณัะตััะธ{}, // ัะฐะทะณัะตััะธ ะฒ ะทะฐะดะฐัะฐั
ะทะฐะปะตะถะธ
rus_verbs:ะทะฐััะพะฟะพัะธัััั{}, // ะทะฐััะพะฟะพัะธัััั ะฒ ะฝะฐัะฐะปะต ัะฟะธัะบะฐ
rus_verbs:ะฟะตัะตัะธัะปััััั{}, // ะฟะตัะตัะธัะปััััั ะฒะพ ะฒะฒะตะดะตะฝะธะธ
rus_verbs:ะฟะพะบะฐัะฐัััั{}, // ะฟะพะบะฐัะฐัััั ะฒ ะฟะฐัะบะต ะฐัััะฐะบัะธะพะฝะพะฒ
rus_verbs:ะธะทะปะพะฒะธัั{}, // ะธะทะปะพะฒะธัั ะฒ ะฟะพะปะต
rus_verbs:ะฟัะพัะปะฐะฒะปััั{}, // ะฟัะพัะปะฐะฒะปััั ะฒ ััะธั
ะฐั
rus_verbs:ะฟัะพะผะพัะธัั{}, // ะฟัะพะผะพัะธัั ะฒ ะปัะถะต
rus_verbs:ะฟะพะดะตะปัะฒะฐัั{}, // ะฟะพะดะตะปัะฒะฐัั ะฒ ะพัะฟััะบะต
rus_verbs:ะฟัะพัััะตััะฒะพะฒะฐัั{}, // ะฟัะพัััะตััะฒะพะฒะฐัั ะฒ ะฟะตัะฒะพะฑััะฝะพะผ ัะพััะพัะฝะธะธ
rus_verbs:ะฟะพะดััะตัะตัั{}, // ะฟะพะดััะตัะตัั ะฒ ะฟะพะดัะตะทะดะต
rus_verbs:ะฟัะธะบัะฟะธัั{}, // ะฟัะธะบัะฟะธัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะฟะตัะตะผะตัะธะฒะฐัั{}, // ะฟะตัะตะผะตัะธะฒะฐัั ะฒ ะบะฐััััะปะต
rus_verbs:ัะธัะบะฐัั{}, // ัะธัะบะฐัั ะฒ ัะณะปั
rus_verbs:ะบัะฟะฐัั{}, // ะบัะฟะฐัั ะฒ ัะตะฟะปะพะน ะฒะพะดะธัะบะต
rus_verbs:ะทะฐะฒะฐัะธัััั{}, // ะทะฐะฒะฐัะธัััั ะฒ ััะฐะบะฐะฝะต
rus_verbs:ะฟัะธััะปะธัััั{}, // ะฟัะธััะปะธัััั ะฒ ัะณะปั
rus_verbs:ะฟะพัััะตะปััั{}, // ะฟะพัััะตะปััั ะฒ ัะธัะต
rus_verbs:ะฝะฐะฒะตัะธัั{}, // ะฝะฐะฒะตัะธัั ะฒ ะฑะพะปัะฝะธัะต
ะธะฝัะธะฝะธัะธะฒ:ะธะทะพะปะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ะธะทะพะปะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะธะทะพะปะธัะพะฒะฐัั ะฒ ะบะฐะผะตัะต
ะณะปะฐะณะพะป:ะธะทะพะปะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะธะทะพะปะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ะฝะตะถะธัััั{}, // ะฝะตะถะธััั ะฒ ะฟะพััะตะปัะบะต
rus_verbs:ะฟัะธัะพะผะธัััั{}, // ะฟัะธัะพะผะธัััั ะฒ ัะบะพะปะต
rus_verbs:ัะฐะทะดะฒะพะธัััั{}, // ัะฐะทะดะฒะพะธัััั ะฒ ะณะปะฐะทะฐั
rus_verbs:ะฝะฐะฒะฐะปะธัั{}, // ะฝะฐะฒะฐะปะธัั ะฒ ัะณะปั
rus_verbs:ะทะฐะผััะพะฒะฐัั{}, // ะทะฐะผััะพะฒะฐัั ะฒ ัะบะปะตะฟะต
rus_verbs:ะฟะพัะตะปััััั{}, // ะฟะพัะตะปััััั ะฒ ะบัะพะฝะต ะดัะฑะฐ
rus_verbs:ะฟะพััะณะธะฒะฐัััั{}, // ะฟะพััะณะธะฒะฐัััั ะฒ ะบัะพะฒะฐัะธ
rus_verbs:ัะบะฐัะฐัั{}, // ัะบะฐัะฐัั ะฒ ะฟะพะตะทะดะต
rus_verbs:ะพัะปะตะถะธะฒะฐัััั{}, // ะพัะปะตะถะธะฒะฐัััั ะฒ ะณะฐะผะฐะบะต
rus_verbs:ัะฐะทะผะตะฝััั{}, // ัะฐะทะผะตะฝััั ะฒ ะบะฐััะต
rus_verbs:ะฟัะพะฟะพะปะพัะบะฐัั{}, // ะฟัะพะฟะพะปะพัะบะฐัั ะฒ ัะธััะพะน ัะตะฟะปะพะน ะฒะพะดะต
rus_verbs:ัะถะฐะฒะตัั{}, // ัะถะฐะฒะตัั ะฒ ะฒะพะดะต
rus_verbs:ัะปะธัะธัั{}, // ัะปะธัะธัั ะฒ ะฟะปะฐะณะธะฐัะต
rus_verbs:ะผััะธัััั{}, // ะผััะธัััั ะฒ ะณะพะปะพะฒะต
rus_verbs:ัะฐััะฒะพัััั{}, // ัะฐััะฒะพัััั ะฒ ะฑะตะฝะทะพะปะต
rus_verbs:ะดะฒะพะธัััั{}, // ะดะฒะพะธัััั ะฒ ะณะปะฐะทะฐั
rus_verbs:ะพะณะพะฒะพัะธัั{}, // ะพะณะพะฒะพัะธัั ะฒ ะดะพะณะพะฒะพัะต
rus_verbs:ะฟะพะดะดะตะปะฐัั{}, // ะฟะพะดะดะตะปะฐัั ะฒ ะดะพะบัะผะตะฝัะต
rus_verbs:ะทะฐัะตะณะธัััะธัะพะฒะฐัััั{}, // ะทะฐัะตะณะธัััะธัะพะฒะฐัััั ะฒ ัะพัะธะฐะปัะฝะพะน ัะตัะธ
rus_verbs:ัะฐััะพะปััะตัั{}, // ัะฐััะพะปััะตัั ะฒ ัะฐะปะธะธ
rus_verbs:ะฟะพะฒะพะตะฒะฐัั{}, // ะฟะพะฒะพะตะฒะฐัั ะฒ ะณะพัะพะดัะบะธั
ััะปะพะฒะธัั
rus_verbs:ะฟัะธะฑัะฐัััั{}, // ะณะฝััะฐัััั ะฟัะธะฑัะฐัััั ะฒ ั
ะปะตะฒั
rus_verbs:ะฟะพะณะปะพัะฐัััั{}, // ะฟะพะณะปะพัะฐัััั ะฒ ะผะตัะฐะปะปะธัะตัะบะพะน ัะพะปัะณะต
rus_verbs:ัั
ะฐัั{}, // ัั
ะฐัั ะฒ ะปะตัั
rus_verbs:ะฟะพะดะฟะธััะฒะฐัััั{}, // ะฟะพะดะฟะธััะฒะฐัััั ะฒ ะฟะตัะธัะธะธ
rus_verbs:ะฟะพะบะฐัะฐัั{}, // ะฟะพะบะฐัะฐัั ะฒ ะผะฐัะธะฝะบะต
rus_verbs:ะธะทะปะตัะธัััั{}, // ะธะทะปะตัะธัััั ะฒ ะบะปะธะฝะธะบะต
rus_verbs:ััะตะฟัั
ะฐัััั{}, // ััะตะฟัั
ะฐัััั ะฒ ะผะตัะบะต
rus_verbs:ะบะธะฟััะธัั{}, // ะบะธะฟััะธัั ะฒ ะบะฐััััะปะต
rus_verbs:ะฟะพะฝะฐัััะพะธัั{}, // ะฟะพะฝะฐัััะพะธัั ะฒ ะฟัะธะฑัะตะถะฝะพะน ะทะพะฝะต
rus_verbs:ะฟะตัะตะฑัะฒะฐัั{}, // ะฟะตัะตะฑัะฒะฐัั ะฒะพ ะฒัะตั
ะตะฒัะพะฟะตะนัะบะธั
ััะพะปะธัะฐั
rus_verbs:ะพะณะปะฐัะฐัั{}, // ะพะณะปะฐัะฐัั ะฒ ะธัะพะณะพะฒะพะน ัะฐััะธ
rus_verbs:ะฟัะตััะฟะตะฒะฐัั{}, // ะฟัะตััะฟะตะฒะฐัั ะฒ ะฝะพะฒะพะผ ะฑะธะทะฝะตัะต
rus_verbs:ะบะพะฝััะปััะธัะพะฒะฐัััั{}, // ะบะพะฝััะปััะธัะพะฒะฐัััั ะฒ ัะตั
ะฟะพะดะดะตัะถะบะต
rus_verbs:ะฝะฐะบะฐะฟะปะธะฒะฐัั{}, // ะฝะฐะบะฐะฟะปะธะฒะฐัั ะฒ ะฟะตัะตะฝะธ
rus_verbs:ะฟะตัะตะผะตัะฐัั{}, // ะฟะตัะตะผะตัะฐัั ะฒ ะบะพะฝัะตะนะฝะตัะต
rus_verbs:ะฝะฐัะปะตะดะธัั{}, // ะฝะฐัะปะตะดะธัั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ะฒััะฒะธัััั{}, // ะฒััะฒะธัััั ะฒ ัะตะทัะปััะต
rus_verbs:ะทะฐะฑัะปัะบะฐัั{}, // ะทะฐะฑัะปัะบะฐัั ะฒ ะฑะพะปะพัะต
rus_verbs:ะพัะฒะฐัะธะฒะฐัั{}, // ะพัะฒะฐัะธะฒะฐัั ะฒ ะผะพะปะพะบะต
rus_verbs:ะทะฐะฟัััะฒะฐัััั{}, // ะทะฐะฟัััะฒะฐัััั ะฒ ะฒะตัะตะฒะบะฐั
rus_verbs:ะฝะฐะณัะตัััั{}, // ะฝะฐะณัะตัััั ะฒ ะผะธะบัะพะฒะพะปะฝะพะฒะพะน ะฟะตัะบะต
rus_verbs:ััะฑะฐัะธัั{}, // ััะฑะฐัะธัั ะฒ ะพัะบัััะพะผ ะผะพัะต
rus_verbs:ัะบะพัะตะฝะธัััั{}, // ัะบะพัะตะฝะธัััั ะฒ ัะพะทะฝะฐะฝะธะธ ัะธัะพะบะธั
ะฝะฐัะพะดะฝัั
ะผะฐัั
rus_verbs:ัะผัะฒะฐัั{}, // ัะผัะฒะฐัั ะฒ ัะฐะทะธะบะต
rus_verbs:ะทะฐัะตะบะพัะฐัั{}, // ะทะฐัะตะบะพัะฐัั ะฒ ะฝะพัั
rus_verbs:ะทะฐั
ะพะดะธัััั{}, // ะทะฐั
ะพะดะธัััั ะฒ ะฟะปะฐัะต
ะธะฝัะธะฝะธัะธะฒ:ะธัะบัะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ะธัะบัะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะธัะบัะฟะฐัั ะฒ ะฟัะพั
ะปะฐะดะฝะพะน ะฒะพะดะธัะบะต
ะณะปะฐะณะพะป:ะธัะบัะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะธัะบัะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะธัะบัะฟะฐะฒ{}, ะดะตะตะฟัะธัะฐััะธะต:ะธัะบัะฟะฐั{},
rus_verbs:ะทะฐะผะพัะพะทะธัั{}, // ะทะฐะผะพัะพะทะธัั ะฒ ั
ะพะปะพะดะธะปัะฝะธะบะต
rus_verbs:ะทะฐะบัะตะฟะปััั{}, // ะทะฐะบัะตะฟะปััั ะฒ ะผะตัะฐะปะปะธัะตัะบะพะผ ะดะตัะถะฐัะตะปะต
rus_verbs:ัะฐัั
ะฒะฐัะฐัั{}, // ัะฐัั
ะฒะฐัะฐัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะธัััะทะฐัั{}, // ะธัััะทะฐัั ะฒ ัััะตะผะฝะพะผ ะฟะพะดะฒะฐะปะต
rus_verbs:ะทะฐัะถะฐะฒะตัั{}, // ะทะฐัะถะฐะฒะตัั ะฒะพ ะฒะปะฐะถะฝะพะน ะฐัะผะพััะตัะต
rus_verbs:ะพะฑะถะฐัะธะฒะฐัั{}, // ะพะฑะถะฐัะธะฒะฐัั ะฒ ะฟะพะดัะพะปะฝะตัะฝะพะผ ะผะฐัะปะต
rus_verbs:ัะผะตัะตัั{}, // ะขั, ะฟะพะดะปัะน ะฟัะตะดะฐัะตะปั, ัะผัะตัั ะฒ ะฝะธัะตัะต
rus_verbs:ะฟะพะดะพะณัะตัั{}, // ะฟะพะดะพะณัะตะน ะฒ ะผะธะบัะพะฒะพะปะฝะพะฒะบะต
rus_verbs:ะฟะพะดะพะณัะตะฒะฐัั{},
rus_verbs:ะทะฐััะฝััั{}, // ะัะทะฝะตัะธะบะธ, ัะฒะตััะบะธ, ัะบัะธะฟะฐัะธ ะธ ะผะตะดะฒะตะดะบะธ ะทะฐััะฝัะปะธ ะฒ ััะฐะฒะต ัะฒะพั ััะตัะบัััั ะผัะทัะบั
rus_verbs:ะฟัะพะดะตะปะฐัั{}, // ะฟัะพะดะตะปะฐัั ะฒ ััะตะฝะต ะดััั
ะธะฝัะธะฝะธัะธะฒ:ะถะตะฝะธัััั{ ะฒะธะด:ัะพะฒะตัั }, // ะถะตะฝะธัััั ะฒ ะขะตั
ะฐัะต
ะธะฝัะธะฝะธัะธะฒ:ะถะตะฝะธัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะณะปะฐะณะพะป:ะถะตะฝะธัััั{ ะฒะธะด:ัะพะฒะตัั },
ะณะปะฐะณะพะป:ะถะตะฝะธัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะถะตะฝะธะฒัะธัั{},
ะดะตะตะฟัะธัะฐััะธะต:ะถะตะฝััั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะถะตะฝะฐััะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะถะตะฝะธะฒัะธะนัั{ะฒะธะด:ัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะถะตะฝััะธะนัั{},
rus_verbs:ะฒัั
ัะฐะฟะฝััั{}, // ะฒัั
ัะฐะฟะฝััั ะฒะพ ัะฝะต
rus_verbs:ะฒัั
ัะฐะฟัะฒะฐัั{}, // ะฒัั
ัะฐะฟัะฒะฐัั ะฒะพ ัะฝะต
rus_verbs:ะฒะพัะพัะฐัััั{}, // ะกะพะฑะฐะบะฐ ะฒะพัะพัะฐะตััั ะฒะพ ัะฝะต
rus_verbs:ะฒะพััะพะทะดะฐะฒะฐัััั{}, // ะฒะพััะพะทะดะฐะฒะฐัััั ะฒ ะฟะฐะผััะธ
rus_verbs:ะฐะบะบะปะธะผะฐัะธะทะธัะพะฒะฐัััั{}, // ะฐะปัะฟะธะฝะธััั ะณะพัะพะฒัััั ะฐะบะบะปะธะผะฐัะธะทะธัะพะฒะฐัััั ะฒ ะณะพัะฐั
ะธะฝัะธะฝะธัะธะฒ:ะฐัะฐะบะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฒะทะฒะพะด ะฑัะป ะฐัะฐะบะพะฒะฐะฝ ะฒ ะปะตัั
ะธะฝัะธะฝะธัะธะฒ:ะฐัะฐะบะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะณะปะฐะณะพะป:ะฐัะฐะบะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะณะปะฐะณะพะป:ะฐัะฐะบะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐัะฐะบะพะฒะฐะฝะฝัะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐัะฐะบะพะฒะฐะฒัะธะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐัะฐะบัััะธะน{},
ะธะฝัะธะฝะธัะธะฒ:ะฐะบะบัะผัะปะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั}, // ัะฝะตัะณะธั ะฑัะปะฐ ะฐะบะบัะผัะปะธัะพะฒะฐะฝะฐ ะฒ ะฟะตัะตะฝะธ
ะธะฝัะธะฝะธัะธะฒ:ะฐะบะบัะผัะปะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฐะบะบัะผัะปะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฐะบะบัะผัะปะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะบะบัะผัะปะธัะพะฒะฐะฝะฝัะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะบะบัะผัะปะธััััะธะน{},
//ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะบะบัะผัะปะธัะพะฒะฐะฒัะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะบะบัะผัะปะธัะพะฒะฐะฒัะธะน{ ะฒะธะด:ัะพะฒะตัั },
rus_verbs:ะฒัะธัะพะฒัะฒะฐัั{}, // ะฒัะธัะพะฒัะฒะฐัั ะฝะพะฒะพะณะพ ะฟะตััะพะฝะฐะถะฐ ะฒ ะฐะฝะธะผะฐัะธั
rus_verbs:ะฒััะฐััะธ{}, // ะะฝ ะฒััะพั ะฒ ะณะปะฐะทะฐั
ะบะพะปะปะตะณ.
rus_verbs:ะธะผะตัั{}, // ะะฝ ะฒัะตะณะดะฐ ะธะผะตะป ะฒ ัะตะทะตัะฒะต ะพัััะพะต ัะปะพะฒัะพ.
rus_verbs:ัะฑะธัั{}, // ัะฑะธัั ะฒ ัะตะฑะต ะทะฒะตัั
ะธะฝัะธะฝะธัะธะฒ:ะฐะฑัะพัะฑะธัะพะฒะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, // ะถะธะดะบะพััั ะฐะฑัะพัะฑะธััะตััั ะฒ ะฟะพะณะปะพัะฐััะตะน ัะบะฐะฝะธ
ะธะฝัะธะฝะธัะธะฒ:ะฐะฑัะพัะฑะธัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะณะปะฐะณะพะป:ะฐะฑัะพัะฑะธัะพะฒะฐัััั{ ะฒะธะด:ัะพะฒะตัั },
ะณะปะฐะณะพะป:ะฐะฑัะพัะฑะธัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ะฟะพััะฐะฒะธัั{}, // ะฟะพััะฐะฒะธัั ะฒ ัะณะปั
rus_verbs:ัะถะธะผะฐัั{}, // ัะถะธะผะฐัั ะฒ ะบัะปะฐะบะต
rus_verbs:ะณะพัะพะฒะธัััั{}, // ะฐะปัะฟะธะฝะธััั ะณะพัะพะฒัััั ะฐะบะบะปะธะผะฐัะธะทะธัะพะฒะฐัััั ะฒ ะณะพัะฐั
rus_verbs:ะฐะบะบัะผัะปะธัะพะฒะฐัััั{}, // ัะฝะตัะณะธั ะฐะบะบัะผัะปะธััะตััั ะฒ ะถะธัะพะฒัั
ะพัะปะพะถะตะฝะธัั
ะธะฝัะธะฝะธัะธะฒ:ะฐะบัะธะฒะธะทะธัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฒ ะณะพัะฐั
ะฐะบัะธะฒะธะทะธัะพะฒะฐะปะธัั ะฟะพะฒััะฐะฝัั
ะธะฝัะธะฝะธัะธะฒ:ะฐะบัะธะฒะธะทะธัะพะฒะฐัััั{ ะฒะธะด:ัะพะฒะตัั },
ะณะปะฐะณะพะป:ะฐะบัะธะฒะธะทะธัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะณะปะฐะณะพะป:ะฐะบัะธะฒะธะทะธัะพะฒะฐัััั{ ะฒะธะด:ัะพะฒะตัั },
rus_verbs:ะฐะฟัะพะฑะธัะพะฒะฐัั{}, // ะฟะธะปะพั ะฐะฟัะพะฑะธัะพะฒะฐะป ะฒ ั
ะพะดะต ะธัะฟััะฐะฝะธะน ะฝะพะฒัะน ัะตะถะธะผ ะฟะปะฐะฝะตัะฐ
rus_verbs:ะฐัะตััะพะฒะฐัั{}, // ะฝะฐัะบะพะดะธะปะตั ะฑัะป ะฐัะตััะพะฒะฐะฝ ะฒ ะฟะพะผะตัะตะฝะธะธ ะบะฐัะต
rus_verbs:ะฑะฐะทะธัะพะฒะฐัั{}, // ัััะฐะฝะพะฒะบะฐ ะฑัะดะตั ะฑะฐะทะธัะพะฒะฐะฝะฐ ะฒ ะปะตัั
rus_verbs:ะฑะฐัะฐั
ัะฐัััั{}, // ะดะตัะธ ะฑะฐัะฐั
ัะฐะปะธัั ะฒ ะฒะพะดะต
rus_verbs:ะฑะฐััะธะบะฐะดะธัะพะฒะฐัััั{}, // ะฟัะตัััะฟะฝะธะบะธ ะฑะฐััะธะบะฐะดะธัััััั ะฒ ะฟะพะผะตัะตะฝะธะธ ะฑะฐะฝะบะฐ
rus_verbs:ะฑะฐัััะฒะพะฒะฐัั{}, // ะกะตะผะตะฝ ะกะตะผะตะฝะพะฒะธั ะฑะฐัััะฒะพะฒะฐะป ะฒ ัะฒะพะตะน ะดะตัะตะฒะฝะต
rus_verbs:ะฑะตััะธะฝััะฒะพะฒะฐัั{}, // ะะพะตะฒะธะบะธ ะฑะตััะธะฝััะฒะพะฒะฐะปะธ ะฒ ะทะฐั
ะฒะฐัะตะฝะฝะพะผ ัะตะปะต
rus_verbs:ะฑะปะฐะถะตะฝััะฒะพะฒะฐัั{}, // ะะพัะพะฑัะธ ะฑะปะฐะถะตะฝััะฒะพะฒะฐะปะธ ะฒ ะบัะพะฝะต ััะฑะธะฝั
rus_verbs:ะฑะปัะถะดะฐัั{}, // ะขััะธััั ะฑะปัะถะดะฐะปะธ ะฒ ะปะตัั
rus_verbs:ะฑัะฐัั{}, // ะะตะฝะฐ ะฑะตัะตั ะดะตะฝัะณะธ ะฒ ััะผะฑะพัะบะต
rus_verbs:ะฑัะพะดะธัั{}, // ะฟะฐัะพัะบะธ ะฑัะพะดะธะปะธ ะฒ ะฟะฐัะบะต
rus_verbs:ะพะฑะพะนัะธ{}, // ะัะฐะทะธะปะธั ะพะฑะพัะปะฐ ะ ะพััะธั ะฒ ัะตะนัะธะฝะณะต
rus_verbs:ะทะฐะดะตัะถะฐัั{}, // ะะฝะฐะผะตะฝะธััะน ัะพะฒะตััะบะธะน ัะธะณััะธัั ะทะฐะดะตัะถะฐะฝ ะฒ ะกะจะ
rus_verbs:ะฑัะปััั
ะฐัััั{}, // ะะพะณะธ ะฑัะปััั
ะฐัััั ะฒ ะฒะพะดะต
rus_verbs:ะฒะฐัะธัััั{}, // ะััะธัะฐ ะฒะฐัะธััั ะฒ ะบะฐััััะปะต
rus_verbs:ะทะฐะบะพะฝัะธัััั{}, // ะญัะฐ ัะตัะตััะธั ะทะฐะบะพะฝัะธะปะฐัั ะฒ 2003 ะณะพะดั
rus_verbs:ะฟัะพะบัััะธะฒะฐัััั{}, // ะะปัั ะฟัะพะบัััะธะฒะฐะตััั ะฒ ะทะฐะผะบะต
rus_verbs:ะฟัะพะบัััะธัััั{}, // ะะปัั ััะธะถะดั ะฟัะพะบัััะธะปัั ะฒ ะทะฐะผะบะต
rus_verbs:ั
ัะฐะฝะธัััั{}, // ะะฐัััะพะนะบะธ ั
ัะฐะฝัััั ะฒ ัะตะบััะพะฒะพะผ ัะฐะนะปะต
rus_verbs:ัะพั
ัะฐะฝััััั{}, // ะะฐัััะพะนะบะธ ัะพั
ัะฐะฝััััั ะฒ ัะตะบััะพะฒะพะผ ัะฐะนะปะต
rus_verbs:ะฒะธัะฐัั{}, // ะะฐะปััะธะบ ะฒะธัะฐะตั ะฒ ะพะฑะปะฐะบะฐั
rus_verbs:ะฒะปะฐะดััะตััะฒะพะฒะฐัั{}, // ะะพัะพะปั ะฒะปะฐะดััะตััะฒัะตั ะฒ ัััะฐะฝะต
rus_verbs:ะฒะปะฐััะฒะพะฒะฐัั{}, // ะะปะธะณะฐัั
ะธ ะฒะปะฐััะฒะพะฒะฐะปะธ ะฒ ัััะฐะฝะต
rus_verbs:ะฒะพะทะฑัะดะธัั{}, // ะฒะพะทะฑัะดะธัั ะฒ ัะตัะดัะต ัะพัะบั
rus_verbs:ะฒะพะทะฑัะถะดะฐัั{}, // ะฒะพะทะฑัะถะดะฐัั ะฒ ัะตัะดัะต ัะพัะบั
rus_verbs:ะฒะพะทะฒััะธัััั{}, // ะฒะพะทะฒััะธัััั ะฒ ะณะปะฐะทะฐั
ัะพะฒัะตะผะตะฝะฝะธะบะพะฒ
rus_verbs:ะฒะพะทะถะตัั{}, // ะฒะพะทะถะตัั ะฒ ั
ัะฐะผะต ะพะณะพะฝั
rus_verbs:ะฒะพะทะถะตัััั{}, // ะะณะพะฝั ะฒะพะทะถัะณัั ะฒ ั
ัะฐะผะต
rus_verbs:ะฒะพะทะถะธะณะฐัั{}, // ะฒะพะทะถะธะณะฐัั ะฒ ั
ัะฐะผะต ะพะณะพะฝั
rus_verbs:ะฒะพะทะถะธะณะฐัััั{}, // ะะณะพะฝั ะฒะพะทะถะธะณะฐะตััั ะฒ ั
ัะฐะผะต
rus_verbs:ะฒะพะทะฝะฐะผะตัะธะฒะฐัััั{}, // ะฒะพะทะฝะฐะผะตัะธะฒะฐัััั ัะนัะธ ะฒ ะผะพะฝะฐััััั
rus_verbs:ะฒะพะทะฝะฐะผะตัะธัััั{}, // ะฒะพะทะฝะฐะผะตัะธัััั ัะนัะธ ะฒ ะผะพะฝะฐััััั
rus_verbs:ะฒะพะทะฝะธะบะฐัั{}, // ะะพะฒัะต ะธะดะตะธ ะฝะตะพะถะธะดะฐะฝะฝะพ ะฒะพะทะฝะธะบะฐัั ะฒ ะบะพะปะธะฝะพะน ะณะพะปะพะฒะต
rus_verbs:ะฒะพะทะฝะธะบะฝััั{}, // ะะพะฒัะต ะธะดะตะนะบะธ ะฒะพะทะฝะธะบะปะธ ะฒ ะณะพะปะพะฒะต
rus_verbs:ะฒะพะทัะพะดะธัััั{}, // ะฒะพะทัะพะดะธัััั ะฒ ะฝะพะฒะพะผ ะบะฐัะตััะฒะต
rus_verbs:ะฒะพะทัะพะถะดะฐัั{}, // ะฒะพะทัะพะถะดะฐัั ะฒ ะฝะพะฒะพะผ ะบะฐัะตััะฒะต
rus_verbs:ะฒะพะทัะพะถะดะฐัััั{}, // ะฒะพะทัะพะถะดะฐัััั ะฒ ะฝะพะฒะพะผ ะฐะผะฟะปัะฐ
rus_verbs:ะฒะพัะพัะธัั{}, // ะฒะพัะพัะธัั ะฒ ะบะฐะผะธะฝะต ะบะพัะตัะณะพะน ะทะพะปั
rus_verbs:ะฒะพัะฟะตะฒะฐัั{}, // ะะพััั ะฒะพัะฟะตะฒะฐัั ะณะตัะพะตะฒ ะฒ ะพะดะฐั
rus_verbs:ะฒะพัะฟะตะฒะฐัััั{}, // ะะตัะพะธ ะฒะพัะฟะตะฒะฐัััั ะฒ ะพะดะฐั
ะฟะพััะฐะผะธ
rus_verbs:ะฒะพัะฟะตัั{}, // ะะพััั ะฒะพัะฟะตะปะธ ะฒ ััะพะน ะพะดะต ะณะตัะพะตะฒ
rus_verbs:ะฒะพัะฟัะตัะธัั{}, // ะฒะพัะฟัะตัะธัั ะฒ ะฟะพะผะตัะตะฝะธะธ ะฐะทะฐััะฝัะต ะธะณัั
rus_verbs:ะฒะพััะปะฐะฒะธัั{}, // ะะพััั ะฒะพััะปะฐะฒะธะปะธ ะฒ ะพะดะฐั
rus_verbs:ะฒะพััะปะฐะฒะปััั{}, // ะะพััั ะฒะพััะปะฐะฒะปััั ะฒ ะพะดะฐั
rus_verbs:ะฒะพััะปะฐะฒะปััััั{}, // ะะตัะพั ะฒะพััะปะฐะฒะปััััั ะฒ ะพะดะฐั
rus_verbs:ะฒะพััะพะทะดะฐัั{}, // ะฒะพััะพะทะดะฐะตั ะฒ ะฟะฐะผััะธ ะพะฑัะฐะท ัะตะปะพะฒะตะบะฐ
rus_verbs:ะฒะพััะพะทะดะฐะฒะฐัั{}, // ะฒะพััะพะทะดะฐัั ะฒ ะฟะฐะผััะธ ะพะฑัะฐะท ัะตะปะพะฒะตะบะฐ
rus_verbs:ะฒะพััะพะทะดะฐัััั{}, // ะฒะพััะพะทะดะฐัััั ะฒ ะฟะฐะผััะธ
rus_verbs:ะฒัะบะธะฟััะธัั{}, // ะฒัะบะธะฟััะธัั ะฒ ัะฐะนะฝะธะบะต ะฒะพะดั
rus_verbs:ะฒัะบะธะฟััะธัััั{}, // ะฒัะบะธะฟััะธัััั ะฒ ัะฐะนะฝะธะบะต
rus_verbs:ะฒัััะตัะธัั{}, // ะฒัััะตัะธัั ะฒ ะบะปะฐััะต ััะฐัะพะณะพ ะฟัะธััะตะปั
rus_verbs:ะฒัััะตัะธัััั{}, // ะฒัััะตัะธัััั ะฒ ะบะปะฐััะต
rus_verbs:ะฒัััะตัะฐัั{}, // ะฒัััะตัะฐัั ะฒ ะปะตัั ะณะพะปะพะดะฝะพะณะพ ะผะตะดะฒะตะดั
rus_verbs:ะฒัััะตัะฐัััั{}, // ะฒัััะตัะฐัััั ะฒ ะบะฐัะต
rus_verbs:ะฒัะฑัะธะฒะฐัั{}, // ะฒัะฑัะธะฒะฐัั ััะพ-ัะพ ะฒ ะฟะพะดะผััะบะฐั
rus_verbs:ะฒัะฑัะธัั{}, // ะฒัะฑัะธัั ััะพ-ัะพ ะฒ ะฟะฐั
ั
rus_verbs:ะฒัะฒะฐะปััั{}, // ะฒัะฒะฐะปััั ะบะพะณะพ-ัะพ ะฒ ะณััะทะธ
rus_verbs:ะฒัะฒะฐะปััััั{}, // ะฒัะฒะฐะปััััั ะฒ ะณััะทะธ
rus_verbs:ะฒัะฒะฐัะธะฒะฐัั{}, // ะฒัะฒะฐัะธะฒะฐัั ะฒ ะผะพะปะพะบะต
rus_verbs:ะฒัะฒะฐัะธะฒะฐัััั{}, // ะฒัะฒะฐัะธะฒะฐัััั ะฒ ะผะพะปะพะบะต
rus_verbs:ะฒัะฒะฐัะธัั{}, // ะฒัะฒะฐัะธัั ะฒ ะผะพะปะพะบะต
rus_verbs:ะฒัะฒะฐัะธัััั{}, // ะฒัะฒะฐัะธัััั ะฒ ะผะพะปะพะบะต
rus_verbs:ะฒัะณััะทะฐัั{}, // ะฒัะณััะทะฐัั ะฒ ัััะต ะพัะฒะตัััะฒะธะต
rus_verbs:ะฒัะณััะทัั{}, // ะฒัะณััะทัั ะฒ ัััะต ะพัะฒะตัััะธะต
rus_verbs:ะฒัะณัะปะธะฒะฐัั{}, // ะฒัะณัะปะธะฒะฐัั ะฒ ะฟะฐัะบะต ัะพะฑะฐะบั
rus_verbs:ะฒัะณัะปััั{}, // ะฒัะณัะปััั ะฒ ะฟะฐัะบะต ัะพะฑะฐะบั
rus_verbs:ะฒัะดะพะปะฑะธัั{}, // ะฒัะดะพะปะฑะธัั ะฒ ััะฒะพะปะต ัะณะปัะฑะปะตะฝะธะต
rus_verbs:ะฒัะถะธัั{}, // ะฒัะถะธัั ะฒ ะฟััััะฝะต
rus_verbs:ะัะธัะบะฐัั{}, // ะัะธัะบะฐัั ะฒ ะฟัะพะณัะฐะผะผะต ะพัะธะฑะบั
rus_verbs:ะฒัะธัะบะฐัััั{}, // ะัะธะฑะบะฐ ะฒัะธัะบะฐะปะฐัั ะฒ ะฟัะพะณัะฐะผะผะต
rus_verbs:ะฒัะธัะบะธะฒะฐัั{}, // ะฒัะธัะบะธะฒะฐัั ะฒ ะฟัะพะณัะฐะผะผะต ะพัะธะฑะบั
rus_verbs:ะฒัะธัะบะธะฒะฐัััั{}, // ะฒัะธัะบะธะฒะฐัััั ะฒ ะฟัะพะณัะฐะผะผะต
rus_verbs:ะฒัะบัะฐะธะฒะฐัั{}, // ะฒัะบัะฐะธะฒะฐัั ะฒ ัะฐัะฟะธัะฐะฝะธะธ ะฒัะตะผั
rus_verbs:ะฒัะบัะฐะธะฒะฐัััั{}, // ะฒัะบัะฐะธะฒะฐัััั ะฒ ัะฐัะฟะธัะฐะฝะธะธ
ะธะฝัะธะฝะธัะธะฒ:ะฒัะบัะฟะฐัััั{aux stress="ะฒ^ัะบัะฟะฐัััั"}, // ะฒัะบัะฟะฐัััั ะฒ ะพะทะตัะต
ะณะปะฐะณะพะป:ะฒัะบัะฟะฐัััั{ะฒะธะด:ัะพะฒะตัั},
rus_verbs:ะฒัะปะพะฒะธัั{}, // ะฒัะปะพะฒะธัั ะฒ ะฟััะดั
rus_verbs:ะฒัะผะฐัะธะฒะฐัั{}, // ะฒัะผะฐัะธะฒะฐัั ะฒ ะผะพะปะพะบะต
rus_verbs:ะฒัะผะฐัะธะฒะฐัััั{}, // ะฒัะผะฐัะธะฒะฐัััั ะฒ ะผะพะปะพะบะต
rus_verbs:ะฒัะฝัั
ะธะฒะฐัั{}, // ะฒัะฝัั
ะธะฒะฐัั ะฒ ััะฐะฒะต ัะปะตะดั
rus_verbs:ะฒัะฟะฐัะบะฐัั{}, // ะฒัะฟะฐัะบะฐัั ะฒ ัะผะพะปะต ัะฒะพั ะพะดะตะถะดั
rus_verbs:ะฒัะฟะฐัะบะฐัััั{}, // ะฒัะฟะฐัะบะฐัััั ะฒ ะณััะทะธ
rus_verbs:ะฒััะฐััะธัั{}, // ะฒััะฐััะธัั ะฒ ัะตะฟะปะธัะต ะฒะตะดัะพ ะพะณัััะธะบะพะฒ
rus_verbs:ะฒััะฐัะธะฒะฐัั{}, // ะฒััะฐัะธะฒะฐัั ะฒ ัะตะฟะปะธัะต ะฟะพะผะธะดะพัั
rus_verbs:ะฒััะฐัะธะฒะฐัััั{}, // ะฒััะฐัะธะฒะฐัััั ะฒ ัะตะฟะปะธัะต
rus_verbs:ะฒััััั{}, // ะฒััััั ะฒ ะทะตะผะปะต ะณะปัะฑะพะบัั ัะผั
rus_verbs:ะฒััะฐะดะธัั{}, // ะฒััะฐะดะธัั ะฒ ะฟััััะฝะฝะพะน ะผะตััะฝะพััะธ
rus_verbs:ะฒััะฐะดะธัััั{}, // ะฒััะฐะดะธัััั ะฒ ะฟััััะฝะฝะพะน ะผะตััะฝะพััะธ
rus_verbs:ะฒััะฐะถะธะฒะฐัั{}, // ะฒััะฐะถะธะฒะฐัั ะฒ ะฟััััะฝะต
rus_verbs:ะฒััะฒะตัะปะธะฒะฐัั{}, // ะฒััะฒะตัะปะธะฒะฐัั ะฒ ะดะพัะบะต ะพัะฒะตัััะฒะธะต
rus_verbs:ะฒััะฒะตัะปะธะฒะฐัััั{}, // ะฒััะฒะตัะปะธะฒะฐัััั ะฒ ััะตะฝะต
rus_verbs:ะฒััะฒะตัะปะธัั{}, // ะฒััะฒะตัะปะธัั ะฒ ััะตะฝะต ะพัะฒะตัััะฒะธะต
rus_verbs:ะฒััะฒะตัะปะธัััั{}, // ะฒััะฒะตัะปะธัััั ะฒ ััะตะฝะต
rus_verbs:ะฒััะบะพะฑะปะธัั{}, // ะฒััะบะพะฑะปะธัั ะฒ ััะพะปะตัะฝะธัะต ะบะฐะฝะฐะฒะบั
rus_verbs:ะฒััะผะฐััะธะฒะฐัั{}, // ะฒััะผะฐััะธะฒะฐัั ะฒ ัะตะผะฝะพัะต
rus_verbs:ะทะฐะผะตัะธัั{}, // ะทะฐะผะตัะธัั ะฒ ะฟะพะผะตัะตะฝะธะธ
rus_verbs:ะพะบะฐะทะฐัััั{}, // ะพะบะฐะทะฐัััั ะฒ ะฟะตัะฒัั
ััะดะฐั
rus_verbs:ะดััะธัั{}, // ะดััะธัั ะฒ ะพะฑัััะธัั
rus_verbs:ะพััะฐะฒะฐัััั{}, // ะพััะฐะฒะฐัััั ะฒ ะบะปะฐััะต
rus_verbs:ะฟะพัะฒะธัััั{}, // ะฒะฟะตัะฒัะต ะฟะพัะฒะธัััั ะฒ ัะธะปัะผะต
rus_verbs:ะปะตะถะฐัั{}, // ะปะตะถะฐัั ะฒ ัััะปััะต
rus_verbs:ัะฐะทะดะฐัััั{}, // ัะฐะทะดะฐัััั ะฒ ะฟะปะตัะฐั
rus_verbs:ะถะดะฐัั{}, // ะถะดะฐัั ะฒ ะทะดะฐะฝะธะธ ะฒะพะบะทะฐะปะฐ
rus_verbs:ะถะธัั{}, // ะถะธัั ะฒ ััััะพะฑะฐั
rus_verbs:ะฟะพััะตะปะธัั{}, // ะฟะพััะตะปะธัั ะฒ ะฟัะธั
ะพะถะตะน
rus_verbs:ะพะบะฐะทัะฒะฐัััั{}, // ะพะบะฐะทัะฒะฐัััั ะฒ ะฝะตะฟัะธััะฝะพะน ัะธััะฐัะธะธ
rus_verbs:ะดะตัะถะฐัั{}, // ะดะตัะถะฐัั ะฒ ะณะพะปะพะฒะต
rus_verbs:ะพะฑะฝะฐััะถะธัั{}, // ะพะฑะฝะฐััะถะธัั ะฒ ัะตะฑะต ัะฟะพัะพะฑะฝะพััั
rus_verbs:ะฝะฐัะธะฝะฐัั{}, // ะฝะฐัะธะฝะฐัั ะฒ ะปะฐะฑะพัะฐัะพัะธะธ
rus_verbs:ัะฐััะบะฐะทัะฒะฐัั{}, // ัะฐััะบะฐะทัะฒะฐัั ะฒ ะปะธัะฐั
rus_verbs:ะพะถะธะดะฐัั{}, // ะพะถะธะดะฐัั ะฒ ะฟะพะผะตัะตะฝะธะธ
rus_verbs:ะฟัะพะดะพะปะถะธัั{}, // ะฟัะพะดะพะปะถะธัั ะฒ ะฟะพะผะตัะตะฝะธะธ
rus_verbs:ัะพััะพััั{}, // ัะพััะพััั ะฒ ะณััะฟะฟะต
rus_verbs:ัะพะดะธัััั{}, // ัะพะดะธัััั ะฒ ััะฑะฐัะบะต
rus_verbs:ะธัะบะฐัั{}, // ะธัะบะฐัั ะฒ ะบะฐัะผะฐะฝะต
rus_verbs:ะธะผะตัััั{}, // ะธะผะตัััั ะฒ ะฝะฐะปะธัะธะธ
rus_verbs:ะณะพะฒะพัะธัััั{}, // ะณะพะฒะพัะธัััั ะฒ ััะตะดะต ะฟะฐะฝะบะพะฒ
rus_verbs:ะบะปัััััั{}, // ะบะปัััััั ะฒ ะฒะตัะฝะพััะธ
rus_verbs:ัะทะฝะฐะฒะฐัั{}, // ัะทะฝะฐะฒะฐัั ะฒ ะฝะตะผ ัะฒะพะตะณะพ ััะฝะฐ
rus_verbs:ะฟัะธะทะฝะฐัััั{}, // ะฟัะธะทะฝะฐัััั ะฒ ะพัะธะฑะบะต
rus_verbs:ัะพะผะฝะตะฒะฐัััั{}, // ัะพะผะฝะตะฒะฐัััั ะฒ ะธัะบัะตะฝะฝะพััะธ
rus_verbs:ัะพะปะพัั{}, // ัะพะปะพัั ะฒ ัััะฟะต
rus_verbs:ะฟะพะฝะฐะดะพะฑะธัััั{}, // ะฟะพะฝะฐะดะพะฑะธัััั ะฒ ััะดะต
rus_verbs:ัะปัะถะธัั{}, // ัะปัะถะธัั ะฒ ะฟะตั
ะพัะต
rus_verbs:ะฟะพัะพะปะพัั{}, // ะฟะพัะพะปะพัั ะฒ ัััะฟะต
rus_verbs:ะฟะพัะฒะปััััั{}, // ะฟะพัะฒะปััััั ะฒ ัะตะฐััะต
rus_verbs:ัะถะฐัั{}, // ัะถะฐัั ะฒ ะพะฑัััะธัั
rus_verbs:ะดะตะนััะฒะพะฒะฐัั{}, // ะดะตะนััะฒะพะฒะฐัั ะฒ ะฟะพััะฐะฝะพะฒะบะต
rus_verbs:ัะตะปะธัั{}, // ัะตะปะธัั ะฒ ะณะพััะธะฝะธัะต
rus_verbs:ะฟะพะนะผะฐัั{}, // ะฟะพะนะผะฐัั ะฒ ะปะตัั
rus_verbs:ัะฒะธะดะฐัั{}, // ัะฒะธะดะฐัั ะฒ ัะพะปะฟะต
rus_verbs:ะฟะพะดะพะถะดะฐัั{}, // ะฟะพะดะพะถะดะฐัั ะฒ ะบะฐะฑะธะฝะตัะต
rus_verbs:ะฟัะพัะตััั{}, // ะฟัะพัะตััั ะฒ ะณะปะฐะทะฐั
rus_verbs:ัะพะฝััั{}, // ัะพะฝััั ะฒ ัะตะบะต
rus_verbs:ะพัััะฐัั{}, // ะพัััะฐัั ะฒ ะถะธะฒะพัะต
rus_verbs:ะพัะธะฑะธัััั{}, // ะพัะธะฑะธัััั ะฒ ัะฐััะตัะฐั
rus_verbs:ะพัะผะตัะธัั{}, // ะพัะผะตัะธัั ะฒ ัะฟะธัะบะต
rus_verbs:ะฟะพะบะฐะทัะฒะฐัั{}, // ะฟะพะบะฐะทัะฒะฐัั ะฒ ะดะธะฝะฐะผะธะบะต
rus_verbs:ัะบัััััั{}, // ัะบัััััั ะฒ ััะฐะฒะต
rus_verbs:ัะฑะตะดะธัััั{}, // ัะฑะตะดะธัััั ะฒ ะบะพััะตะบัะฝะพััะธ
rus_verbs:ะฟัะพะทะฒััะฐัั{}, // ะฟัะพะทะฒััะฐัั ะฒ ะฝะฐััะฝะธะบะฐั
rus_verbs:ัะฐะทะณะพะฒะฐัะธะฒะฐัั{}, // ัะฐะทะณะพะฒะฐัะธะฒะฐัั ะฒ ัะพะนะต
rus_verbs:ะธะทะดะฐัั{}, // ะธะทะดะฐัั ะฒ ะ ะพััะธะธ
rus_verbs:ะฟัะพัะธัะฐัั{}, // ะฟัะพัะธัะฐัั ะฒ ะณะฐะทะตัะต
rus_verbs:ะฟะพะฟัะพะฑะพะฒะฐัั{}, // ะฟะพะฟัะพะฑะพะฒะฐัั ะฒ ะดะตะปะต
rus_verbs:ะทะฐะผะตัะฐัั{}, // ะทะฐะผะตัะฐัั ะฒ ะฟัะพะณัะฐะผะผะต ะพัะธะฑะบั
rus_verbs:ะฝะตััะธ{}, // ะฝะตััะธ ะฒ ััะบะฐั
rus_verbs:ะฟัะพะฟะฐััั{}, // ะฟัะพะฟะฐััั ะฒ ะฟะปะตะฝั
rus_verbs:ะฝะพัะธัั{}, // ะฝะพัะธัั ะฒ ะบะฐัะผะฐะฝะต
rus_verbs:ะณะพัะตัั{}, // ะณะพัะตัั ะฒ ะฐะดั
rus_verbs:ะฟะพะฟัะฐะฒะธัั{}, // ะฟะพะฟัะฐะฒะธัั ะฒ ะฟัะพะณัะฐะผะผะต
rus_verbs:ะทะฐััััั{}, // ะทะฐััััั ะฒ ะฝะตัะดะพะฑะฝะพะน ะฟะพะทะต
rus_verbs:ะฟะพะปััะฐัั{}, // ะฟะพะปััะฐัั ะฒ ะบะฐััะต
rus_verbs:ะฟะพััะตะฑะพะฒะฐัััั{}, // ะฟะพััะตะฑะพะฒะฐัััั ะฒ ัะฐะฑะพัะต
rus_verbs:ัะฟัััะฐัั{}, // ัะฟัััะฐัั ะฒ ัะบะฐัั
rus_verbs:ััะธัััั{}, // ััะธัััั ะฒ ะธะฝััะธัััะต
rus_verbs:ัะฐะทะฒะตัะฝััััั{}, // ัะฐะทะฒะตัะฝััััั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ะฟะพะดะพะทัะตะฒะฐัั{}, // ะฟะพะดะพะทัะตะฒะฐัั ะฒ ะผะพัะตะฝะฝะธัะตััะฒะต
rus_verbs:ะธะณัะฐัั{}, // ะธะณัะฐัั ะฒ ะบะพะผะฐะฝะดะต
rus_verbs:ััะณัะฐัั{}, // ััะณัะฐัั ะฒ ะบะพะผะฐะฝะดะต
rus_verbs:ัััะพะธัั{}, // ัััะพะธัั ะฒ ะดะตัะตะฒะฝะต
rus_verbs:ััััะพะธัั{}, // ััััะพะธัั ะฒ ะดะพะผะต ะฒะตัะตัะธะฝะบั
rus_verbs:ะฝะฐั
ะพะดะธัั{}, // ะฝะฐั
ะพะดะธัั ะฒ ะปะตัั
rus_verbs:ะฝัะถะดะฐัััั{}, // ะฝัะถะดะฐัััั ะฒ ะดะตะฝัะณะฐั
rus_verbs:ะธัะฟััะฐัั{}, // ะธัะฟััะฐัั ะฒ ัะฐะฑะพัะตะน ะพะฑััะฐะฝะพะฒะบะต
rus_verbs:ะผะตะปัะบะฝััั{}, // ะผะตะปัะบะฝััั ะฒ ะฟัะธัะตะปะต
rus_verbs:ะพัััะธัััั{}, // ะพัััะธัััั ะฒ ะทะฐะบัััะพะผ ะฟะพะผะตัะตะฝะธะธ
ะธะฝัะธะฝะธัะธะฒ:ะธัะฟะพะปัะทะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั}, // ะธัะฟะพะปัะทะพะฒะฐัั ะฒ ัะฐะฑะพัะต
ะธะฝัะธะฝะธัะธะฒ:ะธัะฟะพะปัะทะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะธัะฟะพะปัะทะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะธัะฟะพะปัะทะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
rus_verbs:ะปะตัะตัั{}, // ะปะตัะตัั ะฒ ัะฐะผะพะปะตัะต
rus_verbs:ัะผะตััััั{}, // ัะผะตััััั ะฒ ัะธัะบะต
rus_verbs:ะตะทะดะธัั{}, // ะตะทะดะธัั ะฒ ะปะธะผัะทะธะฝะต
rus_verbs:ะทะฐัะฝััั{}, // ะทะฐัะฝััั ะฒ ะฝะตัะดะพะฑะฝะพะน ะฟะพะทะต
rus_verbs:ะทะฐััะฐัั{}, // ะทะฐััะฐัั ะฒ ะฝะตัะพัะผะฐะปัะฝะพะน ะพะฑััะฐะฝะพะฒะบะต
rus_verbs:ะพัะฝััััั{}, // ะพัะฝััััั ะฒ ะฝะตะทะฝะฐะบะพะผะพะน ะพะฑััะฐะฝะพะฒะบะต
rus_verbs:ัะฒะพัะธัััั{}, // ะงัะพ ัะฒะพัะธััั ะฒ ะทะฐะบัััะพะน ะทะพะฝะต
rus_verbs:ัะฐะทะณะปัะดะตัั{}, // ัะฐะทะณะปัะดะตัั ะฒ ัะตะผะฝะพัะต
rus_verbs:ะธะทััะฐัั{}, // ะธะทััะฐัั ะฒ ะตััะตััะฒะตะฝะฝัั
ััะปะพะฒะธัั
rus_verbs:ัะดะตัะถะฐัััั{}, // ัะดะตัะถะฐัััั ะฒ ัะตะดะปะต
rus_verbs:ะฟะพะฑัะฒะฐัั{}, // ะฟะพะฑัะฒะฐัั ะฒ ะทะพะพะฟะฐัะบะต
rus_verbs:ัะปะพะฒะธัั{}, // ัะปะพะฒะธัั ะฒ ัะปะพะฒะฐั
ะฝะพัะบั ะพััะฐัะฝะธั
rus_verbs:ะฟัะธะพะฑัะตััะธ{}, // ะฟัะธะพะฑัะตััะธ ะฒ ะปะฐะฒะบะต
rus_verbs:ะธััะตะทะฐัั{}, // ะธััะตะทะฐัั ะฒ ััะผะฐะฝะต
rus_verbs:ัะฒะตัััั{}, // ัะฒะตัััั ะฒ ัะฒะพะตะน ะฝะตะฒะธะฝะพะฒะฝะพััะธ
rus_verbs:ะฟัะพะดะพะปะถะฐัััั{}, // ะฟัะพะดะพะปะถะฐัััั ะฒ ะฒะพะทะดัั
ะต
rus_verbs:ะพัะบััะฒะฐัั{}, // ะพัะบััะฒะฐัั ะฒ ะณะพัะพะดะต ะฝะพะฒัะน ััะฐะดะธะพะฝ
rus_verbs:ะฟะพะดะดะตัะถะฐัั{}, // ะฟะพะดะดะตัะถะฐัั ะฒ ะฟะฐัะบะต ะฟะพััะดะพะบ
rus_verbs:ัะพะปะธัั{}, // ัะพะปะธัั ะฒ ะฑะพัะบะต
rus_verbs:ะฟัะพะถะธัั{}, // ะฟัะพะถะธัั ะฒ ะดะตัะตะฒะฝะต
rus_verbs:ัะพะทะดะฐะฒะฐัั{}, // ัะพะทะดะฐะฒะฐัั ะฒ ัะตะฐััะต
rus_verbs:ะพะฑััะถะดะฐัั{}, // ะพะฑััะถะดะฐัั ะฒ ะบะพะปะปะตะบัะธะฒะต
rus_verbs:ะทะฐะบะฐะทะฐัั{}, // ะทะฐะบะฐะทะฐัั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะพัััะบะฐัั{}, // ะพัััะบะฐัั ะฒ ะณะฐัะฐะถะต
rus_verbs:ััะฝััั{}, // ััะฝััั ะฒ ะบัะตัะปะต
rus_verbs:ะทะฐะดะตัะถะฐัััั{}, // ะทะฐะดะตัะถะฐัััั ะฒ ัะตะฐััะต
rus_verbs:ะฟะพะดะพะฑัะฐัั{}, // ะฟะพะดะพะฑัะฐัั ะฒ ะบะพะปะปะตะบัะธะธ
rus_verbs:ะฟัะพะฑะพะฒะฐัั{}, // ะฟัะพะฑะพะฒะฐัั ะฒ ัะฐะฑะพัะต
rus_verbs:ะบััะธัั{}, // ะบััะธัั ะฒ ะทะฐะบัััะพะผ ะฟะพะผะตัะตะฝะธะธ
rus_verbs:ััััะฐะธะฒะฐัั{}, // ััััะฐะธะฒะฐัั ะฒ ะปะตัั ะทะฐัะฐะดั
rus_verbs:ัััะฐะฝะพะฒะธัั{}, // ัััะฐะฝะพะฒะธัั ะฒ ะฑะฐะณะฐะถะฝะธะบะต
rus_verbs:ะทะฐะฟะตัะตัั{}, // ะทะฐะฟะตัะตัั ะฒ ัะฐัะฐะต
rus_verbs:ัะพะดะตัะถะฐัั{}, // ัะพะดะตัะถะฐัั ะฒ ะดะพััะฐัะบะต
rus_verbs:ัะธะฝะตัั{}, // ัะธะฝะตัั ะฒ ะบะธัะปะพัะพะดะฝะพะน ะฐัะผะพััะตัะต
rus_verbs:ัะปััะฐัััั{}, // ัะปััะฐัััั ะฒ ะณะพะปะพัะต
rus_verbs:ะทะฐะบัััััั{}, // ะทะฐะบัััััั ะฒ ะทะดะฐะฝะธะธ
rus_verbs:ัะบััะฒะฐัััั{}, // ัะบััะฒะฐัััั ะฒ ะบะฒะฐััะธัะต
rus_verbs:ัะพะดะธัั{}, // ัะพะดะธัั ะฒ ะฑะพะปัะฝะธัะต
rus_verbs:ะพะฟะธัะฐัั{}, // ะพะฟะธัะฐัั ะฒ ะทะฐะผะตัะบะฐั
rus_verbs:ะฟะตัะตั
ะฒะฐัะธัั{}, // ะฟะตัะตั
ะฒะฐัะธัั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ะผะตะฝััั{}, // ะผะตะฝััั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ัะบััะฒะฐัั{}, // ัะบััะฒะฐัั ะฒ ััะถะพะน ะบะฒะฐััะธัะต
rus_verbs:ััะธัะฝััั{}, // ััะธัะฝััั ะฒ ััะฐะปัะฝัั
ะพะฑัััะธัั
rus_verbs:ะพััะฐะฝะฐะฒะปะธะฒะฐัััั{}, // ะพััะฐะฝะฐะฒะปะธะฒะฐัััั ะฒ ะณะพััะธะฝะธัะต
rus_verbs:ะผะตะปัะบะฐัั{}, // ะผะตะปัะบะฐัั ะฒ ัะตะปะตะฒะธะทะพัะต
rus_verbs:ะฟัะธัััััะฒะพะฒะฐัั{}, // ะฟัะธัััััะฒะพะฒะฐัั ะฒ ะฐัะดะธัะพัะธะธ
rus_verbs:ัะบัะฐััั{}, // ัะบัะฐััั ะฒ ะผะฐะณะฐะทะธะฝะต
rus_verbs:ะฟะพะฑะตะดะธัั{}, // ะฟะพะฑะตะดะธัั ะฒ ะฒะพะนะฝะต
rus_verbs:ัะฐัะฟะพะปะพะถะธัััั{}, // ัะฐัะฟะพะปะพะถะธัััั ะฒ ะณะพััะธะฝะธัะต
rus_verbs:ัะฟะพะผัะฝััั{}, // ัะฟะพะผัะฝััั ะฒ ัะฒะพะตะน ะบะฝะธะณะต
rus_verbs:ะฟะปััั{}, // ะฟะปััั ะฒ ััะฐัะพะน ะฑะพัะบะต
rus_verbs:ะฝะฐััะฟะฐัั{}, // ะฝะฐััะฟะฐัั ะฒ ะณะปัะฑะธะฝะต
rus_verbs:ะฟัะพัะฒะปััััั{}, // ะฟัะพัะฒะปััััั ะฒ ัะฐะฑะพัะต
rus_verbs:ะทะฐัะธั
ะฝััั{}, // ะทะฐัะธั
ะฝััั ะฒ ะฝะพัะต
rus_verbs:ะฟะพัััะพะธัั{}, // ะฟะพัััะพะธัั ะฒ ะณะฐัะฐะถะต
rus_verbs:ะฟะพะดะดะตัะถะธะฒะฐัั{}, // ะฟะพะดะดะตัะถะธะฒะฐัั ะฒ ะธัะฟัะฐะฒะฝะพะผ ัะพััะพัะฝะธะธ
rus_verbs:ะทะฐัะฐะฑะพัะฐัั{}, // ะทะฐัะฐะฑะพัะฐัั ะฒ ััะฐััะฐะฟะต
rus_verbs:ัะปะพะผะฐัั{}, // ัะปะพะผะฐัั ะฒ ััััะฐะฒะต
rus_verbs:ัะฝะธะผะฐัั{}, // ัะฝะธะผะฐัั ะฒ ะณะฐัะดะตัะพะฑะต
rus_verbs:ัะพั
ัะฐะฝะธัั{}, // ัะพั
ัะฐะฝะธัั ะฒ ะบะพะปะปะตะบัะธะธ
rus_verbs:ัะฐัะฟะพะปะฐะณะฐัััั{}, // ัะฐัะฟะพะปะฐะณะฐัััั ะฒ ะพัะดะตะปัะฝะพะผ ะบะฐะฑะธะฝะตัะต
rus_verbs:ััะฐะถะฐัััั{}, // ััะฐะถะฐัััั ะฒ ัะตััะฝะพะผ ะฑะพั
rus_verbs:ัะฟััะบะฐัััั{}, // ัะฟััะบะฐัััั ะฒ ะฑะฐัะธัะบะฐัะต
rus_verbs:ัะฝะธััะพะถะธัั{}, // ัะฝะธััะพะถะธัั ะฒ ัั
ัะพะฝะต
rus_verbs:ะธะทััะธัั{}, // ะธะทััะธัั ะฒ ะตััะตััะฒะตะฝะฝัั
ััะปะพะฒะธัั
rus_verbs:ัะพะถะดะฐัััั{}, // ัะพะถะดะฐัััั ะฒ ะผัะบะฐั
rus_verbs:ะฟัะตะฑัะฒะฐัั{}, // ะฟัะตะฑัะฒะฐัั ะฒ ะฟัะพัััะฐัะธะธ
rus_verbs:ะฟัะธะปะตัะตัั{}, // ะฟัะธะปะตัะตัั ะฒ ะฐััะพะฑััะต
rus_verbs:ะดะพะณะฝะฐัั{}, // ะดะพะณะฝะฐัั ะฒ ะฟะตัะตัะปะบะต
rus_verbs:ะธะทะพะฑัะฐะทะธัั{}, // ะธะทะพะฑัะฐะทะธัั ะฒ ัะฐะฝัะต
rus_verbs:ะฟัะพะตั
ะฐัั{}, // ะฟัะพะตั
ะฐัั ะฒ ะปะตะณะบะพะฒััะบะต
rus_verbs:ัะฑะตะดะธัั{}, // ัะฑะตะดะธัั ะฒ ัะฐะทัะผะฝะพััะธ
rus_verbs:ะฟัะธะณะพัะพะฒะธัั{}, // ะฟัะธะณะพัะพะฒะธัั ะฒ ะดัั
ะพะฒะบะต
rus_verbs:ัะพะฑะธัะฐัั{}, // ัะพะฑะธัะฐัั ะฒ ะปะตัั
rus_verbs:ะฟะพะฟะปััั{}, // ะฟะพะฟะปััั ะฒ ะบะฐัะตัะต
rus_verbs:ะดะพะฒะตัััั{}, // ะดะพะฒะตัััั ะฒ ัะฟัะฐะฒะปะตะฝะธะธ
rus_verbs:ัะฐะทะพะฑัะฐัััั{}, // ัะฐะทะพะฑัะฐัััั ะฒ ะทะฐะบะพะฝะฐั
rus_verbs:ะปะพะฒะธัั{}, // ะปะพะฒะธัั ะฒ ะพะทะตัะต
rus_verbs:ะฟัะพะตััั{}, // ะฟัะพะตััั ะฒ ะบััะบะต ะผะตัะฐะปะปะฐ ะพัะฒะตัััะธะต
rus_verbs:ัะฟัััะฐัััั{}, // ัะฟัััะฐัััั ะฒ ะฟะพะดะฒะฐะปะต
rus_verbs:ะฟัะพะฒะพะทะณะปะฐัะธัั{}, // ะฟัะพะฒะพะทะณะปะฐัะธัั ะฒ ัะตัะธ
rus_verbs:ะธะทะปะพะถะธัั{}, // ะธะทะปะพะถะธัั ะฒ ัะฒะพัะผ ะฒััััะฟะปะตะฝะธะธ
rus_verbs:ะทะฐะผััััั{}, // ะทะฐะผััััั ะฒ ะบะพัะธะดะพัะต
rus_verbs:ัะฐะทะดะฐะฒะฐัััั{}, // ะัะธะบ ัะณัะฐัะฐ ัะฐะทะดะฐะตััั ะฒ ะดะถัะฝะณะปัั
rus_verbs:ะดะพะบะฐะทะฐัั{}, // ะะฒัะพั ะดะพะบะฐะทะฐะป ะฒ ัะฒะพะตะน ัะฐะฑะพัะต, ััะพ ัะตะพัะตะผะฐ ะฒะตัะฝะฐ
rus_verbs:ั
ัะฐะฝะธัั{}, // ั
ัะฐะฝะธัั ะฒ ัะบะฐััะปะบะต
rus_verbs:ัััะธัั{}, // ัััะธัั ะฒ ะบะปะฐััะต
ะณะปะฐะณะพะป:ัะฐัััะฟะฐัััั{ aux stress="ัะฐัััะฟ^ะฐัััั" }, // ัะฐัััะฟะฐัััั ะฒ ะธะทะฒะธะฝะตะฝะธัั
ะธะฝัะธะฝะธัะธะฒ:ัะฐัััะฟะฐัััั{ aux stress="ัะฐัััะฟ^ะฐัััั" },
rus_verbs:ัะตััะธัั{}, // ัะตััะธัั ะฒ ัะตััะฐะดะบะต
rus_verbs:ะพััะฐะทะธัััั{}, // ะพััะฐะทะธัััั ะฒ ะฐััะตััะฐัะต
rus_verbs:ะณัะตัั{}, // ะณัะตัั ะฒ ะผะธะบัะพะฒะพะปะฝะพะฒะบะต
rus_verbs:ะทะฐัััะฐัั{}, // ะัะพ-ัะพ ะทะฐัััะฐะป ะฒ ะณะปัะฑะธะฝะต ะปะตัะฐ
rus_verbs:ัะฐัััะถะดะฐัั{}, // ะะฒัะพั ัะฐัััะถะดะฐะตั ะฒ ัะฒะพะตะน ััะฐััะต
rus_verbs:ะพัะฒะพะฑะพะดะธัั{}, // ะะฑะฒะธะฝัะตะผัะต ะฑัะปะธ ะพัะฒะพะฑะพะถะดะตะฝั ะฒ ะทะฐะปะต ััะดะฐ
rus_verbs:ะพะบััะถะฐัั{}, // ะพะบััะถะฐัั ะฒ ะปะตัั
rus_verbs:ัะพะฟัะพะฒะพะถะดะฐัั{}, // ัะพะฟัะพะฒะพะถะดะฐัั ะฒ ะพะฟะตัะฐัะธะธ
rus_verbs:ะทะฐะบะฐะฝัะธะฒะฐัััั{}, // ะทะฐะบะฐะฝัะธะฒะฐัััั ะฒ ะดะพัะพะณะต
rus_verbs:ะฟะพัะตะปะธัััั{}, // ะฟะพัะตะปะธัััั ะฒ ะทะฐะณะพัะพะดะฝะพะผ ะดะพะผะต
rus_verbs:ะพั
ะฒะฐััะฒะฐัั{}, // ะพั
ะฒะฐััะฒะฐัั ะฒ ั
ัะพะฝะพะปะพะณะธะธ
rus_verbs:ะทะฐะฟะตัั{}, // ะทะฐะฟะตัั ะฒ ะบะธะฝะพ
ะธะฝัะธะฝะธัะธะฒ:ะฟัะพะฒะพะทะธัั{ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะฟัะพะฒะพะทะธัั ะฒ ะฑะฐะณะฐะถะต
ะณะปะฐะณะพะป:ะฟัะพะฒะพะทะธัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
rus_verbs:ะผะพัะธัั{}, // ะผะพัะธัั ะฒ ัะพััะธัะต
rus_verbs:ะฟะตัะตะฒะตัะฝััััั{}, // ะฟะตัะตะฒะตัะฝััััั ะฒ ะฟะพะปััะต
rus_verbs:ัะปะตัะตัั{}, // ัะปะตัะตัั ะฒ ัะตะฟะปัะต ะบัะฐั
rus_verbs:ัะดะตัะถะฐัั{}, // ัะดะตัะถะฐัั ะฒ ััะบะฐั
rus_verbs:ะฟัะตัะปะตะดะพะฒะฐัั{}, // ะฟัะตัะปะตะดะพะฒะฐัั ะฒ ะปัะฑะพะน ะดััะณะพะน ัััะฐะฝะต
rus_verbs:ะดัะฐัััั{}, // ะดัะฐัััั ะฒ ะฑะฐัะต
rus_verbs:ะฟัะพัะธะดะตัั{}, // ะฟัะพัะธะดะตัั ะฒ ะบะปะฐััะต
rus_verbs:ัะฑะธัะฐัััั{}, // ัะฑะธัะฐัััั ะฒ ะบะฒะฐััะธัะต
rus_verbs:ัะพะดัะพะณะฝััััั{}, // ัะพะดัะพะณะฝััััั ะฒ ะฟัะธัััะฟะต ะพัะฒัะฐัะตะฝะธั
rus_verbs:ะฟัะณะฐัั{}, // ะฟัะณะฐัั ะฒ ะฟัะตััะต
rus_verbs:ะพััะตะฐะณะธัะพะฒะฐัั{}, // ะพััะตะฐะณะธัะพะฒะฐัั ะฒ ะฟัะตััะต
rus_verbs:ะฟัะพะฒะตัััั{}, // ะฟัะพะฒะตัััั ะฒ ะฐะฟะฟะฐัะฐัะต
rus_verbs:ัะฑะตะถะดะฐัั{}, // ัะฑะตะถะดะฐัั ะฒ ะพััััััะฒะธะธ ะฐะปััะตัะฝะฐัะธะฒ
rus_verbs:ะปะตัะฐัั{}, // ะปะตัะฐัั ะฒ ะบะพะผัะพััะฐะฑะตะปัะฝะพะผ ัะฐััะฝะพะผ ัะฐะผะพะปััะต
rus_verbs:ัะพะปะฟะธัััั{}, // ัะพะปะฟะธัััั ะฒ ัะพะนะต
rus_verbs:ะฟะปะฐะฒะฐัั{}, // ะฟะปะฐะฒะฐัั ะฒ ัะฟะตัะธะฐะปัะฝะพะผ ะบะพัััะผะต
rus_verbs:ะฟัะพะฑััั{}, // ะฟัะพะฑััั ะฒ ะฒะพะดะต ัะปะธัะบะพะผ ะดะพะปะณะพ
rus_verbs:ะฟัะธะบะธะฝััั{}, // ะฟัะธะบะธะฝััั ะฒ ัะผะต
rus_verbs:ะทะฐัััััั{}, // ะทะฐัััััั ะฒ ะปะธััะต
rus_verbs:ะผะตัะฐัััั{}, // ะผะตัะฐัััั ะฒ ะบัะพะฒะฐัะต
rus_verbs:ัะถะตัั{}, // ัะถะตัั ะฒ ะฟะตัะบะต
rus_verbs:ัะฐััะปะฐะฑะธัััั{}, // ัะฐััะปะฐะฑะธัััั ะฒ ะฒะฐะฝะฝะพะน
rus_verbs:ััะปัั
ะฐัั{}, // ััะปัั
ะฐัั ะฒ ะฐะฒัะพะฑััะต
rus_verbs:ัะดะตัะถะฐัั{}, // ัะดะตัะถะฐัั ะฒ ะฒะตััะธะบะฐะปัะฝะพะผ ะฟะพะปะพะถะตะฝะธะธ
rus_verbs:ะพะฑัะฐะทะพะฒะฐัััั{}, // ะพะฑัะฐะทะพะฒะฐัััั ะฒ ะฒะตัั
ะฝะธั
ัะปะพัั
ะฐัะผะพััะตัั
rus_verbs:ัะฐััะผะพััะตัั{}, // ัะฐััะผะพััะตัั ะฒ ะบะฐะฟะปะต ะฒะพะดั
rus_verbs:ะฟัะพัะผะพััะตัั{}, // ะฟัะพัะผะพััะตัั ะฒ ะฑัะฐัะทะตัะต
rus_verbs:ััะตััั{}, // ััะตััั ะฒ ะฟะปะฐะฝะฐั
rus_verbs:ัะตะทะถะฐัั{}, // ัะตะทะถะฐัั ะฒ ััะตะน-ัะพ ะผะฐัะธะฝะต
rus_verbs:ะฟะพั
ะพัะพะฝะธัั{}, // ะฟะพั
ะพัะพะฝะธัั ะฒ ะผะตัะทะปะพะน ะทะตะผะปะต
rus_verbs:ัะฐัััะฝััััั{}, // ัะฐัััะฝััััั ะฒ ัะฐััะปะฐะฑะปะตะฝะฝะพะน ะฟะพะทะต
rus_verbs:ะพะฑะฝะฐััะถะธัััั{}, // ะพะฑะฝะฐััะถะธัััั ะฒ ััะถะพะน ััะผะบะต
rus_verbs:ะณัะปััั{}, // ะณัะปััั ะฒ ะฟะฐัะบะต
rus_verbs:ััะพะฝััั{}, // ััะพะฝััั ะฒ ัะตะบะต
rus_verbs:ะทะฐะถะฐัั{}, // ะทะฐะถะฐัั ะฒ ะผะตะดะฒะตะถัะธั
ะพะฑัััะธัั
rus_verbs:ััะพะผะฝะธัััั{}, // ััะพะผะฝะธัััั ะฒ ะพะฑัะตะบัะธะฒะฝะพััะธ
rus_verbs:ัะฐะฝัะตะฒะฐัั{}, // ัะฐะฝัะตะฒะฐัั ะฒ ัะฟะพััะทะฐะปะต
rus_verbs:ะฟัะพะฝะพัะธัััั{}, // ะฟัะพะฝะพัะธัััั ะฒ ะณะพะปะพะฒะต
rus_verbs:ัััะดะธัััั{}, // ัััะดะธัััั ะฒ ะบะพะพะฟะตัะฐัะธะฒะต
ะณะปะฐะณะพะป:ะทะฐััะฟะฐัั{ aux stress="ะทะฐััะฟ^ะฐัั" ะฟะตัะตั
ะพะดะฝะพััั:ะฝะตะฟะตัะตั
ะพะดะฝัะน }, // ะทะฐััะฟะฐัั ะฒ ัะฟะฐะปัะฝะพะผ ะผะตัะบะต
ะธะฝัะธะฝะธัะธะฒ:ะทะฐััะฟะฐัั{ aux stress="ะทะฐััะฟ^ะฐัั" ะฟะตัะตั
ะพะดะฝะพััั:ะฝะตะฟะตัะตั
ะพะดะฝัะน },
rus_verbs:ัััะธัั{}, // ัััะธัั ะฒ ัััะธะปัะฝะพะผ ัะบะฐัั
rus_verbs:ะทะฐัะตะฒะตะปะธัััั{}, // ะทะฐัะตะฒะตะปะธัััั ะฒ ััะฐะฒะต
rus_verbs:ะพะฑะดัะผัะฒะฐัั{}, // ะพะฑะดัะผัะฒะฐัั ะฒ ัะฟะพะบะพะนะฝะพะน ะพะฑััะฐะฝะพะฒะบะต
rus_verbs:ะฟัะพะผะตะปัะบะฝััั{}, // ะฟัะพะผะตะปัะบะฝััั ะฒ ะพะบะฝะต
rus_verbs:ะฟะพััะฐััะฒะพะฒะฐัั{}, // ะฟะพััะฐััะฒะพะฒะฐัั ะฒ ะพะฑััะถะดะตะฝะธะธ
rus_verbs:ะทะฐะบัััั{}, // ะทะฐะบัััั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ะทะฐะฟะธัะฐัั{}, // ะทะฐะฟะธัะฐัั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ะทะฐะบััะฒะฐัั{}, // ะทะฐะบััะฒะฐัั ะฒ ะดะพะผะต
rus_verbs:ะทะฐะฑะปะพะบะธัะพะฒะฐัั{}, // ะทะฐะฑะปะพะบะธัะพะฒะฐัั ะฒ ะดะพะผะต
rus_verbs:ะทะฐัะฒะตััะธ{}, // ะ ัะฐะดะฐั
ะทะฐัะฒะตะปะฐ ัะธัะตะฝั
rus_verbs:ะบัะธัะฐัั{}, // ะะฐะบะพะต-ัะพ ะถะธะฒะพัะฝะพะต ะบัะธัะฐะปะพ ะฒ ะฝะพัะฝะพะผ ะปะตัั.
rus_verbs:ะฟะพะณะปะพัะธัั{}, // ัะพัะพะฝ, ะฟะพะณะปะพัะตะฝะฝัะน ะฒ ัะตัะตะฟัะพัะต
rus_verbs:ััะพััั{}, // ะฒะพะนัะบะฐ, ััะพัะฒัะธะต ะฒ ะ ะธะผะต
rus_verbs:ะทะฐะบะฐะปะธัั{}, // ะฒะตัะตัะฐะฝั, ะทะฐะบะฐะปะตะฝะฝัะต ะฒ ะฑะพัั
rus_verbs:ะฒััััะฟะฐัั{}, // ะฟัะธัะปะพัั ะฒััััะฟะฐัั ะฒ ััััะผะต.
rus_verbs:ะฒััััะฟะธัั{}, // ะฟัะธัะปะพัั ะฒััััะฟะธัั ะฒ ััััะผะต.
rus_verbs:ะทะฐะบะพะฟะพัะธัััั{}, // ะััะธ ะทะฐะบะพะฟะพัะธะปะธัั ะฒ ััะฐะฒะต
rus_verbs:ะฒะพัะฟะปะฐะผะตะฝะธัััั{}, // ัะผะตัั, ะฒะพัะฟะปะฐะผะตะฝะธะฒัะฐััั ะฒ ัะธะปะธะฝะดัะต
rus_verbs:ะฒะพัะฟะปะฐะผะตะฝััััั{}, // ัะผะตัั, ะฒะพัะฟะปะฐะผะตะฝัััะฐััั ะฒ ัะธะปะธะฝะดัะต
rus_verbs:ะทะฐะบััะฒะฐัััั{}, // ะทะฐะบััะฒะฐัััั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ะฟัะพะฒะฐะปะธัััั{}, // ะฟัะพะฒะฐะปะธัััั ะฒ ะฟัะพะบะฐัะต
ะดะตะตะฟัะธัะฐััะธะต:ะฐะฒัะพัะธะทะธััััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะณะปะฐะณะพะป:ะฐะฒัะพัะธะทะธัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะธะฝัะธะฝะธัะธะฒ:ะฐะฒัะพัะธะทะธัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฐะฒัะพัะธะทะธัะพะฒะฐัััั ะฒ ัะธััะตะผะต
rus_verbs:ัััะตััะฒะพะฒะฐัั{}, // ัััะตััะฒะพะฒะฐัั ะฒ ะฒะฐะบััะผะต
ะดะตะตะฟัะธัะฐััะธะต:ะฝะฐั
ะพะดััั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐั
ะพะดะธะฒัะธะนัั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐั
ะพะดััะธะนัั{},
ะณะปะฐะณะพะป:ะฝะฐั
ะพะดะธัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะธะฝัะธะฝะธัะธะฒ:ะฝะฐั
ะพะดะธัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฝะฐั
ะพะดะธัััั ะฒ ะฒะฐะบััะผะต
rus_verbs:ัะตะณะธัััะธัะพะฒะฐัั{}, // ัะตะณะธัััะธัะพะฒะฐัั ะฒ ะธะฝัะฟะตะบัะธะธ
ะณะปะฐะณะพะป:ะฟะตัะตัะตะณะธัััะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฟะตัะตัะตะณะธัััะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะธะฝัะธะฝะธัะธะฒ:ะฟะตัะตัะตะณะธัััะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ะฟะตัะตัะตะณะธัััะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ะฟะตัะตัะตะณะธัััะธัะพะฒะฐัั ะฒ ะธะฝัะฟะตะบัะธะธ
rus_verbs:ะฟะพะบะพะฒััััััั{}, // ะฟะพะบะพะฒััััััั ะฒ ะฝะพัั
rus_verbs:ะพััะฐััั{}, // ะพััะฐััั ะฒ ะบะธะฟััะบะต
rus_verbs:ัะฐัะฟะธะฝะฐัััั{}, // ัะฐัะฟะธะฝะฐัััั ะฒ ะฟัะพะบะปััะธัั
rus_verbs:ะพัะผะตะฝะธัั{}, // ะะธะฝะธััะตัััะฒะพ ัะฒัะทะธ ะฟัะตะดะปะฐะณะฐะตั ะพัะผะตะฝะธัั ะฒะฝัััะตะฝะฝะธะน ัะพัะผะธะฝะณ ะฒ ะ ะพััะธะธ
rus_verbs:ััะพะปะบะฝััััั{}, // ะะผะตัะธะบะฐะฝัะบะธะน ััะผะธะฝะตั ะธ ัะฟะพะฝัะบะธะน ัะฐะฝะบะตั ััะพะปะบะฝัะปะธัั ะฒ ะะตััะธะดัะบะพะผ ะทะฐะปะธะฒะต
rus_verbs:ัะตะฝะธัั{}, // ะะฝ ะพัะตะฝั ัะตะฝะธะป ะฒ ััะฐัััั
ะบัะฐัะบะพััั ะธะทะปะพะถะตะฝะธั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะตััะฐััะฝัะน{}, // ะะฝ ะพัะตะฝั ะฝะตััะฐััะตะฝ ะฒ ัะตะผะตะนะฝะพะน ะถะธะทะฝะธ.
rus_verbs:ะพะฑัััะฝะธัััั{}, // ะะฝ ะพะฑัััะฝะธะปัั ะฒ ะปัะฑะฒะธ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะตัะฒะตัะดัะน{}, // ะะฝ ะฝะตัะฒััะด ะฒ ะธััะพัะธะธ.
rus_verbs:ะทะฐะฝะธะผะฐัััั{}, // ะะฝ ะทะฐะฝะธะผะฐะตััั ะฒ ัะธัะฐะปัะฝะพะผ ะทะฐะปะต.
rus_verbs:ะฒัะฐัะฐัััั{}, // ะะฝ ะฒัะฐัะฐะตััั ะฒ ัััะฝัั
ะบััะณะฐั
.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฟะพะบะพะนะฝัะน{}, // ะะฝ ะฑัะป ัะฟะพะบะพะตะฝ ะธ ัะฒะตัะตะฝ ะฒ ะทะฐะฒััะฐัะฝะตะผ ะดะฝะต.
rus_verbs:ะฑะตะณะฐัั{}, // ะะฝ ะฑะตะณะฐะป ะฟะพ ะณะพัะพะดั ะฒ ะฟะพะธัะบะฐั
ะบะฒะฐััะธัั.
rus_verbs:ะทะฐะบะปััะฐัั{}, // ะะธััะผะพ ะทะฐะบะปััะฐะปะพ ะฒ ัะตะฑะต ะพัะตะฝั ะฒะฐะถะฝัะต ัะฒะตะดะตะฝะธั.
rus_verbs:ััะฐะฑะฐััะฒะฐัั{}, // ะะปะณะพัะธัะผ ััะฐะฑะฐััะฒะฐะตั ะฒ ะฟะพะปะพะฒะธะฝะต ัะปััะฐะตะฒ.
rus_verbs:ัะฟะตัะธะฐะปะธะทะธัะพะฒะฐัััั{}, // ะผั ัะฟะตัะธะฐะปะธะทะธััะตะผัั ะฒ ัะพะทะดะฐะฝะธะธ ัะดะตัะฝะพะณะพ ะพััะถะธั
rus_verbs:ััะฐะฒะฝะธัััั{}, // ะะธะบัะพ ะฝะต ะผะพะถะตั ััะฐะฒะฝะธัััั ั ะฝะธะผ ะฒ ะทะฝะฐะฝะธัั
.
rus_verbs:ะฟัะพะดะพะปะถะฐัั{}, // ะัะพะดะพะปะถะฐะนัะต ะฒ ัะพะผ ะถะต ะดัั
ะต.
rus_verbs:ะณะพะฒะพัะธัั{}, // ะะต ะณะพะฒะพัะธัะต ะพะฑ ััะพะผ ะฒ ะฟัะธัััััะฒะธะธ ััะตััะธั
ะปะธั.
rus_verbs:ะฑะพะปัะฐัั{}, // ะะต ะฑะพะปัะฐะน ะฒ ะฟัะธัััััะฒะธะธ ะฝะฐัะฐะปัะฝะธะบะฐ!
rus_verbs:ะฟัะพะฑะพะปัะฐัััั{}, // ะะต ะฟัะพะฑะพะปัะฐะนัั ะฒ ะฟัะธัััััะฒะธะธ ะฝะฐัะฐะปัะฝะธะบะฐ!
rus_verbs:ะฟะพะฒัะพัะธัั{}, // ะะฝ ะดะพะปะถะตะฝ ะฟะพะฒัะพัะธัั ัะฒะพะธ ะฟะพะบะฐะทะฐะฝะธั ะฒ ะฟัะธัััััะฒะธะธ ัะฒะธะดะตัะตะปะตะน
rus_verbs:ะฟะพะปััะธัั{}, // ัะตะบัะพั ะฟะพะทะดัะฐะฒะธะป ัััะดะตะฝัะพะฒ, ะฟะพะปััะธะฒัะธั
ะฒ ััะพะผ ัะตะผะตัััะต ะฟะพะฒััะตะฝะฝัั ััะธะฟะตะฝะดะธั
rus_verbs:ะฟัะธะพะฑัะตัะฐัั{}, // ะญัั ะตะดั ะผั ะฟัะธะพะฑัะตัะฐะตะผ ะฒ ัะพัะตะดะฝะตะผ ะผะฐะณะฐะทะธะฝะต.
rus_verbs:ัะฐัั
ะพะดะธัััั{}, // ะะฐัะฐ ะธ ะะตัั ัะฐัั
ะพะดัััั ะฒะพ ะฒะทะณะปัะดะฐั
rus_verbs:ัั
ะพะดะธัััั{}, // ะัะต ะดะพัะพะณะธ ัั
ะพะดัััั ะฒ ะะพัะบะฒะต
rus_verbs:ัะฑะธัะฐัั{}, // ัะฑะธัะฐัั ะฒ ะบะพะผะฝะฐัะต
rus_verbs:ัะดะพััะพะฒะตัััััั{}, // ะพะฝ ัะดะพััะพะฒะตััะตััั ะฒ ะปะธัะฝะพััะธ ัะฟะตัะธะฐะปะธััะฐ
rus_verbs:ัะตะดะธะฝััััั{}, // ัะตะดะธะฝััััั ะฒ ะฟััััะฝะต
rus_verbs:ัะถะธะฒะฐัััั{}, // ัะถะธะฒะฐัััั ะฒ ะพะดะฝะพะผ ะบะพะปะปะตะบัะธะฒะต
rus_verbs:ัะบะพัััั{}, // ัะบะพัััั ะดััะณะฐ ะฒ ะทะฐะฑัะฒัะธะฒะพััะธ
rus_verbs:ัะธัะฐัั{}, // ะพะฝ ัะธัะฐะป ะพะฑ ััะพะผ ะฒ ะถััะฝะฐะปะต
rus_verbs:ัะพััะพััััั{}, // ะ ะะทัะฐะธะปะต ัะพััะพัััั ะดะพััะพัะฝัะต ะฟะฐัะปะฐะผะตะฝััะบะธะต ะฒัะฑะพัั
rus_verbs:ะฟะพะณะธะฑะฝััั{}, // ะกะฟะธัะพะบ ะฟะพะณะธะฑัะธั
ะฒ ะฐะฒะธะฐะบะฐัะฐัััะพัะต ะฟะพะด ะฏัะพัะปะฐะฒะปะตะผ
rus_verbs:ัะฐะฑะพัะฐัั{}, // ะฏ ัะฐะฑะพัะฐั ะฒ ัะตะฐััะต.
rus_verbs:ะฟัะธะทะฝะฐัั{}, // ะฏ ะฟัะธะทะฝะฐะป ะฒ ะฝัะผ ััะฐัะพะณะพ ะดััะณะฐ.
rus_verbs:ะฟัะตะฟะพะดะฐะฒะฐัั{}, // ะฏ ะฟัะตะฟะพะดะฐั ะฒ ัะฝะธะฒะตััะธัะตัะต.
rus_verbs:ะฟะพะฝะธะผะฐัั{}, // ะฏ ะฟะปะพั
ะพ ะฟะพะฝะธะผะฐั ะฒ ะถะธะฒะพะฟะธัะธ.
rus_verbs:ะฒะพะดะธัััั{}, // ะฝะตะธะทะฒะตััะฝัะน ะฝะฐัะบะต ะทะฒะตัั, ะบะพัะพััะน ะฒะพะดะธััั ะฒ ะถะฐัะบะธั
ััะพะฟะธัะตัะบะธั
ะปะตัะฐั
rus_verbs:ัะฐะทัะฐะทะธัััั{}, // ะ ะะพัะบะฒะต ัะฐะทัะฐะทะธะปะฐัั ัะฟะธะดะตะผะธั ะณัะธะฟะฟะฐ
rus_verbs:ะทะฐะผะตัะตัั{}, // ะฒัั ัะพะปะฟะฐ ะทะฐะผะตัะปะฐ ะฒ ะฒะพัั
ะธัะตะฝะธะธ
rus_verbs:ัะธะดะตัั{}, // ะฏ ะปัะฑะปั ัะธะดะตัั ะฒ ััะพะผ ัะดะพะฑะฝะพะผ ะบัะตัะปะต.
rus_verbs:ะธะดัะธ{}, // ะฏ ะธะดั ะฒ ะฝะตะพะฟัะตะดะตะปัะฝะฝะพะผ ะฝะฐะฟัะฐะฒะปะตะฝะธะธ.
rus_verbs:ะทะฐะฑะพะปะตัั{}, // ะฏ ะทะฐะฑะพะปะตะป ะฒ ะดะพัะพะณะต.
rus_verbs:ะตั
ะฐัั{}, // ะฏ ะตะดั ะฒ ะฐะฒัะพะฑััะต
rus_verbs:ะฒะทััั{}, // ะฏ ะฒะทัะป ะบะฝะธะณั ะฒ ะฑะธะฑะปะธะพัะตะบะต ะฝะฐ ะฝะตะดะตะปั.
rus_verbs:ะฟัะพะฒะตััะธ{}, // ะฎะฝัะต ะณะพะดั ะพะฝ ะฟัะพะฒัะป ะฒ ะัะฐะปะธะธ.
rus_verbs:ะฒััะฐะฒะฐัั{}, // ะญัะพั ัะปััะฐะน ะถะธะฒะพ ะฒััะฐัั ะฒ ะผะพะตะน ะฟะฐะผััะธ.
rus_verbs:ะฒะพะทะฒััะธัั{}, // ะญัะพ ัะพะฑััะธะต ะฒะพะทะฒััะธะปะพ ะตะณะพ ะฒ ะพะฑัะตััะฒะตะฝะฝะพะผ ะผะฝะตะฝะธะธ.
rus_verbs:ะฟัะพะธะทะพะนัะธ{}, // ะญัะพ ะฟัะพะธะทะพัะปะพ ะฒ ะพะดะฝะพะผ ะณะพัะพะดะต ะฒ ะฏะฟะพะฝะธะธ.
rus_verbs:ะฟัะธะฒะธะดะตัััั{}, // ะญัะพ ะผะฝะต ะฟัะธะฒะธะดะตะปะพัั ะฒะพ ัะฝะต.
rus_verbs:ะดะตัะถะฐัััั{}, // ะญัะพ ะดะตะปะพ ะดะตัะถะธััั ะฒ ะฑะพะปััะพะผ ัะตะบัะตัะต.
rus_verbs:ะฟัะธะฒะธัััั{}, // ะญัะพ ะฒััะฐะถะตะฝะธะต ะฝะต ะฟัะธะฒะธะปะพัั ะฒ ััััะบะพะผ ัะทัะบะต.
rus_verbs:ะฒะพัััะฐะฝะพะฒะธัััั{}, // ะญัะธ ะฟะธัะฐัะตะปะธ ะฒะพัััะฐะฝะพะฒะธะปะธัั ะฒ ะฟัะฐะฒะฐั
.
rus_verbs:ะฑััั{}, // ะญัะฐ ะบะฝะธะณะฐ ะตััั ะฒ ะปัะฑะพะผ ะบะฝะธะถะฝะพะผ ะผะฐะณะฐะทะธะฝะต.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะพะฟัะปััะฝัะน{}, // ะญัะฐ ะธะดะตั ะพัะตะฝั ะฟะพะฟัะปััะฝะฐ ะฒ ะผะฐััะฐั
.
rus_verbs:ััะผะตัั{}, // ะจัะผะธั ะฒ ะณะพะปะพะฒะต.
rus_verbs:ะพััะฐัััั{}, // ะจะปัะฟะฐ ะพััะฐะปะฐัั ะฒ ะฟะพะตะทะดะต.
rus_verbs:ะฒััะฐะถะฐัััั{}, // ะฅะฐัะฐะบัะตั ะฟะธัะฐัะตะปั ะปัััะต ะฒัะตะณะพ ะฒััะฐะถะฐะตััั ะฒ ะตะณะพ ะฟัะพะธะทะฒะตะดะตะฝะธัั
.
rus_verbs:ะฒะพัะฟะธัะฐัั{}, // ะฃัะธัะตะปัะฝะธัะฐ ะฒะพัะฟะธัะฐะปะฐ ะฒ ะดะตััั
ะปัะฑะพะฒั ะบ ะฟัะธัะพะดะต.
rus_verbs:ะฟะตัะตัะพั
ะฝััั{}, // ะฃ ะผะตะฝั ะฒ ะณะพัะปะต ะฟะตัะตัะพั
ะปะพ.
rus_verbs:ัะตะบะพัะฐัั{}, // ะฃ ะผะตะฝั ะฒ ะณะพัะปะต ัะตะบะพัะตั.
rus_verbs:ะบะพะปะพัั{}, // ะฃ ะผะตะฝั ะฒ ะฑะพะบั ะบะพะปะตั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฒะตะถะธะน{}, // ะกะพะฑััะธะต ะตัั ัะฒะตะถะพ ะฒ ะฟะฐะผััะธ.
rus_verbs:ัะพะฑัะฐัั{}, // ะกะพะฑะตัะธัะต ะฒัะตั
ััะตะฝะธะบะพะฒ ะฒะพ ะดะฒะพัะต.
rus_verbs:ะฑะตะปะตัั{}, // ะกะฝะตะณ ะฑะตะปะตะตั ะฒ ะณะพัะฐั
.
rus_verbs:ัะดะตะปะฐัั{}, // ะกะบะพะปัะบะพ ะพััะพะณัะฐัะธัะตัะบะธั
ะพัะธะฑะพะบ ัั ัะดะตะปะฐะป ะฒ ะดะธะบัะฐะฝัะต?
rus_verbs:ัะฐััั{}, // ะกะฐั
ะฐั ัะฐะตั ะฒ ะบะธะฟััะบะต.
rus_verbs:ะถะฐัั{}, // ะกะฐะฟะพะณ ะถะผัั ะฒ ะฟะพะดััะผะต.
rus_verbs:ะฒะพะทะธัััั{}, // ะ ะตะฑััะฐ ะฒะพะทัััั ะฒ ัะณะปั.
rus_verbs:ัะฐัะฟะพััะถะฐัััั{}, // ะัะพัั ะฝะต ัะฐัะฟะพััะถะฐัััั ะฒ ััะถะพะผ ะดะพะผะต.
rus_verbs:ะบััะถะธัััั{}, // ะะฝะธ ะบััะถะธะปะธัั ะฒ ะฒะฐะปััะต.
rus_verbs:ะฒัััะฐะฒะปััั{}, // ะะฝะธ ะฒัััะฐะฒะปััั ะตะณะพ ะฒ ัะผะตัะฝะพะผ ะฒะธะดะต.
rus_verbs:ะฑัะฒะฐัั{}, // ะะฝะฐ ัะฐััะพ ะฑัะฒะฐะตั ะฒ ะพะฑัะตััะฒะต.
rus_verbs:ะฟะตัั{}, // ะะฝะฐ ะฟะพัั ะฒ ะพะฟะตัะต.
rus_verbs:ัะพะนัะธัั{}, // ะัะต ัะฒะธะดะตัะตะปะธ ัะพัะปะธัั ะฒ ัะฒะพะธั
ะฟะพะบะฐะทะฐะฝะธัั
.
rus_verbs:ะฒะฐะปััััั{}, // ะะตัะธ ะฒะฐะปัะปะธัั ะฒ ะฑะตัะฟะพััะดะบะต.
rus_verbs:ะฟัะพะนัะธ{}, // ะะตัั ะดะตะฝั ะฟัะพััะป ะฒ ะฑะตะณะพัะฝะต.
rus_verbs:ะฟัะพะดะฐะฒะฐัั{}, // ะ ััะพะผ ะผะฐะณะฐะทะธะฝะต ะฟัะพะดะฐัั ะพะฑัะฒั.
rus_verbs:ะทะฐะบะปััะฐัััั{}, // ะ ััะพะผ ะทะฐะบะปััะฐะตััั ะฒัั ัััะฝะพััั.
rus_verbs:ะทะฒะตะฝะตัั{}, // ะ ััะฐั
ะทะฒะตะฝะธั.
rus_verbs:ะฟัะพัััะฟะธัั{}, // ะ ััะผะฐะฝะต ะฟัะพัััะฟะธะปะธ ะพัะตััะฐะฝะธั ะบะพัะฐะฑะปั.
rus_verbs:ะฑะธัั{}, // ะ ัะฐะดั ะฑััั ัะพะฝัะฐะฝ.
rus_verbs:ะฟัะพัะบะพะปัะทะฝััั{}, // ะ ัะตัะธ ะฟัะพัะบะพะปัะทะฝัะป ัะฟััะบ.
rus_verbs:ะพััะฐะฒะธัั{}, // ะะต ะพััะฐะฒั ัะพะฒะฐัะธัะฐ ะฒ ะพะฟะฐัะฝะพััะธ.
rus_verbs:ะฟัะพะณัะปััั{}, // ะั ะฟัะพะณัะปัะปะธ ัะฐั ะฒ ะฟะฐัะบะต.
rus_verbs:ะฟะตัะตะฑะธัั{}, // ะั ะฟะตัะตะฑะธะปะธ ะฒัะฐะณะพะฒ ะฒ ะฑะพั.
rus_verbs:ะพััะฐะฝะพะฒะธัััั{}, // ะั ะพััะฐะฝะพะฒะธะปะธัั ะฒ ะฟะตัะฒะพะน ะฟะพะฟะฐะฒัะตะนัั ะณะพััะธะฝะธัะต.
rus_verbs:ะฒะธะดะตัั{}, // ะะฝ ะผะฝะพะณะพะต ะฒะธะดะตะป ะฒ ะถะธะทะฝะธ.
// ะณะปะฐะณะพะป:ะฟัะพั
ะพะดะธัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะะตัะตะดะฐ ะฟัะพั
ะพะดะธะปะฐ ะฒ ะดััะถะตััะฒะตะฝะฝะพะน ะฐัะผะพััะตัะต.
rus_verbs:ะฟะพะดะฐัั{}, // ะะฒัะพั ะฟะพะดะฐะป ัะฒะพะธั
ะณะตัะพะตะฒ ะฒ ัะตะฐะปะธััะธัะตัะบะธั
ัะพะฝะฐั
.
rus_verbs:ะบะธะฝััั{}, // ะะฝ ะบะธะฝัะป ะผะตะฝั ะฒ ะฑะตะดะต.
rus_verbs:ะฟัะธั
ะพะดะธัั{}, // ะัะธั
ะพะดะธ ะฒ ัะตะฝััะฑัะต
rus_verbs:ะฒะพัะบัะตัะฐัั{}, // ะฒะพัะบัะตัะฐัั ะฒ ะฟะฐะผััะธ
rus_verbs:ัะพะตะดะธะฝััั{}, // ัะพะตะดะธะฝััั ะฒ ัะตะฑะต
rus_verbs:ัะฐะทะฑะธัะฐัััั{}, // ัะผะตะฝะธะต ัะฐะทะฑะธัะฐัััั ะฒ ะฒะตัะฐั
rus_verbs:ะดะตะปะฐัั{}, // ะ ะตั ะบะพะผะฝะฐัะต ะดะตะปะฐะปะธ ะพะฑััะบ.
rus_verbs:ะฒะพัะฐัะธัััั{}, // ะ ะทะฐะปะต ะฒะพัะฐัะธะปะฐัั ะณะปัะฑะพะบะฐั ัะธัะธะฝะฐ.
rus_verbs:ะฝะฐัะฐัััั{}, // ะ ะดะตัะตะฒะฝะต ะฝะฐัะฐะปะธัั ะฟะพะปะตะฒัะต ัะฐะฑะพัั.
rus_verbs:ะฑะปะตัะฝััั{}, // ะ ะณะพะปะพะฒะต ะฑะปะตัะฝัะปะฐ ั
ะพัะพัะฐั ะผััะปั.
rus_verbs:ะฒะตััะตัััั{}, // ะ ะณะพะปะพะฒะต ะฒะตััะธััั ะฒัะตัะฐัะฝะธะน ัะฐะทะณะพะฒะพั.
rus_verbs:ะฒะตััั{}, // ะ ะฒะพะทะดัั
ะต ะฒะตะตั ะฟัะพั
ะปะฐะดะพะน.
rus_verbs:ะฒะธัะตัั{}, // ะ ะฒะพะทะดัั
ะต ะฒะธัะธั ะทะฝะพะน.
rus_verbs:ะฝะพัะธัััั{}, // ะ ะฒะพะทะดัั
ะต ะฝะพััััั ะบะพะผะฐัั.
rus_verbs:ะณัะตััะธ{}, // ะัะตััะธ ะฒ ัะฟะพะบะพะนะฝะพะน ะฒะพะดะต ะฑัะดะตั ะฝะตะผะฝะพะณะพ ะปะตะณัะต, ะฝะพ ัะบััะฝะตะต
rus_verbs:ะฒะพัะบัะตัะธัั{}, // ะฒะพัะบัะตัะธัั ะฒ ะฟะฐะผััะธ
rus_verbs:ะฟะพะฟะปะฐะฒะฐัั{}, // ะฟะพะฟะปะฐะฒะฐัั ะฒ 100-ะผะตััะพะฒะพะผ ะฑะฐััะตะนะฝะต
rus_verbs:ะฟะพัััะฐะดะฐัั{}, // ะ ะผะฐััะพะฒะพะน ะดัะฐะบะต ะฟะพัััะฐะดะฐะป 23-ะปะตัะฝะธะน ะผัะถัะธะฝะฐ
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฒะตัะตะฝะฝัะน{ ะฟัะธัะฐััะธะต }, // ะะฝะฐ ัะฒะตัะตะฝะฐ ะฒ ัะฒะพะธั
ัะธะปะฐั
.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะพััะพัะฝะฝัะน{}, // ะะฝะฐ ะฟะพััะพัะฝะฝะฐ ะฒะพ ะฒะบััะฐั
.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะธะปัะฝัะน{}, // ะะฝ ะฝะต ัะธะปัะฝ ะฒ ะผะฐัะตะผะฐัะธะบะต.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะพะฒะธะฝะฝัะน{}, // ะะฝ ะฝะต ะฟะพะฒะธะฝะตะฝ ะฒ ััะพะผ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒะพะทะผะพะถะฝัะน{}, // ะฃัะฐะณะฐะฝั, ัะธะปัะฝัะต ะณัะพะทั ะธ ะดะฐะถะต ัะผะตััะธ ะฒะพะทะผะพะถะฝั ะฒ ะบะพะฝัะต ะฟะตัะธะพะดะฐ ัะธะปัะฝะพะน ะถะฐัั
rus_verbs:ะฒัะฒะตััะธ{}, // ัะฟะพัะพะฑะฝัะน ะปะตัะฐัั ะฝะฐะด ะทะตะผะปะตะน ะบัะพะบะพะดะธะป ะฑัะป ะฒัะฒะตะดะตะฝ ะฒ ัะตะบัะตัะฝะพะน ะปะฐะฑะพัะฐัะพัะธะธ
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝัะถะฝัะน{}, // ัะบะพะฒะพัะพะดะบะฐ ัะพะถะต ะฝัะถะฝะฐ ะฒ ั
ะพะทัะนััะฒะต.
rus_verbs:ัะตััั{}, // ะะฝะฐ ัะตะปะฐ ะฒ ัะตะฝะธ
rus_verbs:ะทะฐะปะธะฒะฐัััั{}, // ะฒ ะฝะฐัะตะผ ะฟะฐัะบะต ะทะฐะปะธะฒะฐัััั ัะพะปะพะฒัะธ
rus_verbs:ัะฐะทะฝะตััะธ{}, // ะ ะปะตัั ะพะณะพะฝั ะฟะพะถะฐัะฐ ะผะณะฝะพะฒะตะฝะฝะพ ัะฐะทะฝะตัะปะพ
rus_verbs:ััะฒััะฒะพะฒะฐัััั{}, // ะ ััะฟะปะพะผ, ะฝะพ ัััะพะผ ะฒะพะทะดัั
ะต ะพัััะพ ััะฒััะฒะพะฒะฐะปะพัั ะดัั
ะฐะฝะธะต ะพัะตะฝะธ
// rus_verbs:ัะฐััะธ{}, // ะดะตัะตะฒะพ, ัะฐััััะตะต ะฒ ะปะตัั
rus_verbs:ะฟัะพะธัั
ะพะดะธัั{}, // ััะพ ะฟัะพะธัั
ะพะดะธั ะฒ ะฟะพะปะธะบะปะธะฝะฝะธะบะต
rus_verbs:ัะฟะฐัั{}, // ะบัะพ ัะฟะธั ะฒ ะผะพะตะน ะบัะพะฒะฐัะธ
rus_verbs:ะผััั{}, // ะผััั ะผะฐัะธะฝั ะฒ ัะฐะดั
ะะ_ะะะค(ัะฐัะธัั), // ะ ะฒะพะทะดัั
ะต ัะฐัะธะปะพ ะฑะตะทะผะพะปะฒะธะต
ะะ_ะะะค(ะผะตััะธ), // ะผะตััะธ ะฒ ะฟัะธั
ะพะถะตะน ะฟะพะป
ะะ_ะะะค(ะฟัััะฐัั), // ะฟัััะฐัั ะฒ ัะผะต
ะะ_ะะะค(ัะฒะธะดะตัั), ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฒะธะดะตะฒัะธะน{}, ะดะตะตะฟัะธัะฐััะธะต:ัะฒะธะดะตะฒ{}, // ัะฒะธะดะตะป ะฟะตัะธะพะดะธัะตัะบัั ัะฐะฑะปะธัั ัะปะตะผะตะฝัะพะฒ ะฒะพ ัะฝะต.
// ะะ_ะะะค(ัะพะฑัะฐัััั), // ัะพะฑัะฐัััั ะฒ ะฟะพััั
ะะ_ะะะค(ัะปััะธัััั), // ััะพ-ัะพ ัะปััะธะปะพัั ะฒ ะฑะพะปัะฝะธัะต
ะะ_ะะะค(ะทะฐะถะตัััั), // ะฒ ะฝะตะฑะต ะทะฐะถะณะปะธัั ะทะฒัะทะดั
ะะ_ะะะค(ะบัะฟะธัั), // ะบัะฟะธ ะผะพะปะพะบะฐ ะฒ ะผะฐะณะฐะทะธะฝะต
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟัะพะฟะฐะณะฐะฝะดะธัะพะฒะฐะฒัะธะนัั{} // ะณััะฟะฟะฐ ัััะดะตะฝัะพะฒ ัะฝะธะฒะตััะธัะตัะฐ ะดััะถะฑั ะฝะฐัะพะดะพะฒ, ะฐะบัะธะฒะฝะพ ะฟัะพะฟะฐะณะฐะฝะดะธัะพะฒะฐะฒัะตะนัั ะฒ ะกะกะกะ
}
// ะงัะพะฑั ัะฐะทัะตัะธัั ัะฒัะทัะฒะฐะฝะธะต ะฒ ะฟะฐััะตัะฝะฐั
ัะธะฟะฐ: ะฟะพะพะฑะตะดะฐัั ะฒ macdonalds
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะ_ะัะตะดะป ะฟัะตะดะปะพะณ:ะฒ{} @regex("[a-z]+[0-9]*") }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะ_ะัะตะดะป ะฟัะตะดะปะพะณ:ะฒ{} *:*{ ะฟะฐะดะตะถ:ะฟัะตะดะป } }
then return true
}
// ะก ะปะพะบะฐัะธะฒะพะผ:
// ัะพะฑัะฐัััั ะฒ ะฟะพััั
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะ_ะัะตะดะป ะฟัะตะดะปะพะณ:ะฒ{} ัััะตััะฒะธัะตะปัะฝะพะต:*{ ะฟะฐะดะตะถ:ะผะตัั } }
then return true
}
#endregion ะัะตะดะปะพะถะฝัะน
#region ะะธะฝะธัะตะปัะฝัะน
// ะะปั ะณะปะฐะณะพะปะพะฒ ะดะฒะธะถะตะฝะธั ั ะฒััะฐะถะตะฝะฝัะผ ะฝะฐะฟัะฐะฒะปะตะฝะธะตะผ ะดะตะนััะฒะธั ะผะพะถะตั ะฟัะธัะพะตะดะธะฝััััั
// ะฟัะตะดะปะพะถะฝัะน ะฟะฐััะตัะฝ ั ะฒะธะฝะธัะตะปัะฝัะผ ะฟะฐะดะตะถะพะผ.
wordentry_set ะะป_ะ_ะะธะฝ =
{
rus_verbs:ะฒะดะฐะฒะธัััั{}, // ะัะปะพ ะฑะพะปัะฝะพ ะฒะดะฐะฒะธะปะพัั ะฒ ะฟะพะทะฒะพะฝะพะบ.
ะณะปะฐะณะพะป:ะฒะฒะตัะณะฝััั{}, // ะะฒัั
ะฟัะตะปะตััะฝะตะนัะธั
ะดะฐะผ ะพะฝ ะฒะฒะตัะณะฝัะป ะฒ ะณะพัะต.
ะณะปะฐะณะพะป:ะฒะฒะตัะณะฐัั{},
ะธะฝัะธะฝะธัะธะฒ:ะฒะฒะตัะณะฝััั{},
ะธะฝัะธะฝะธัะธะฒ:ะฒะฒะตัะณะฐัั{},
rus_verbs:ะดะฒะธะฝััััั{}, // ะะฒะธะฝัะปะธัั ะฒ ะฟััั ะธ ะผั.
rus_verbs:ัะฟะปะฐะฒะฐัั{}, // ะกะฟะปะฐะฒะฐัั ะฒ ะ ะพััะธั!
rus_verbs:ัะปะพะถะธัััั{}, // ะฃะปะพะถะธัััั ะฒ ะฒะพัะบัะตัะตะฝัะต.
rus_verbs:ัะฟะตัะธัั{}, // ะกะฟะตัะธัะต ะฒ ะะพะฝะดะพะฝ
rus_verbs:ะบะธะฝััั{}, // ะะธะฝััะต ะฒ ะผะพัะต.
rus_verbs:ะฟัะพัะธัััั{}, // ะัะพัะธะปะฐัั ะฒ ะะธะบะฐัะฐะณัะฐ.
rus_verbs:ะฟัะธัะพะฟะฐัั{}, // ะัะธัะพะฟะฐะป ะฒ ะัะดะฐะฟะตัั.
rus_verbs:ัะบะฐัะฐัััั{}, // ะกะบะฐัะฐะปัั ะฒ ะัะฐัะฝะพัััะบ.
rus_verbs:ัะพัะบะพะปัะทะฝััั{}, // ะกะพัะบะพะปัะทะฝัะป ะฒ ะฟะธะบะต.
rus_verbs:ัะพัะบะฐะปัะทัะฒะฐัั{},
rus_verbs:ะธะณัะฐัั{}, // ะะณัะฐะป ะฒ ะดัััะต.
ะณะปะฐะณะพะป:ะฐะนะดะฐ{}, // ะะนะดะฐ ะฒ ะบะฐะผะพัั.
rus_verbs:ะพัะทัะฒะฐัั{}, // ะัะทัะฒะฐะปะธ ะฒ ะะพัะบะฒั...
rus_verbs:ัะพะพะฑัะฐัััั{}, // ะกะพะพะฑัะฐะตััั ะฒ ะะพะฝะดะพะฝ.
rus_verbs:ะฒะดัะผะฐัััั{}, // ะะดัะผะฐะนัะตัั ะฒ ะฝะธั
.
rus_verbs:ะฟัะพะตั
ะฐัั{}, // ะัะพะตั
ะฐัั ะฒ ะัะฝะตะฒะพ...
rus_verbs:ัะฟััะณะธะฒะฐัั{}, // ะกะฟััะณะธะฒะฐะตะผ ะฒ ะฝะตะณะพ.
rus_verbs:ะฒะตัะธัั{}, // ะะตัั ะฒ ะฒะฐั!
rus_verbs:ะฟัะธะฑััั{}, // ะัะธะฑัะป ะฒ ะะพะดะผะพัะบะพะฒัะต.
rus_verbs:ะฟะตัะตั
ะพะดะธัั{}, // ะะตัะตั
ะพะดะธัะต ะฒ ัะบะพะปั.
rus_verbs:ะดะพะปะพะถะธัั{}, // ะะพะปะพะถะธะปะธ ะฒ ะะพัะบะฒั.
rus_verbs:ะฟะพะดะฐะฒะฐัััั{}, // ะะพะดะฐะฒะฐัััั ะฒ ะ ะพััะธั?
rus_verbs:ัะฟััะณะฝััั{}, // ะกะฟััะณะฝัะป ะฒ ะฝะตะณะพ.
rus_verbs:ะฒัะฒะตะทัะธ{}, // ะัะฒะตะทะปะธ ะฒ ะะธัะฐะน.
rus_verbs:ะฟัะพะฟะธั
ะธะฒะฐัั{}, // ะฏ ะพัะตะฝั ะฐะบะบััะฐัะฝะพ ะฟัะพะฟะธั
ะธะฒะฐะป ะดัะปะพ ะฒ ะฝะพะทะดัั.
rus_verbs:ะฟัะพะฟะธั
ะฝััั{},
rus_verbs:ััะฐะฝัะฟะพััะธัะพะฒะฐัััั{},
rus_verbs:ะทะฐะบัะฐะดัะฒะฐัััั{}, // ะฒ ะณะพะปะพะฒั ะฝะฐัะฐะปะธ ะทะฐะบัะฐะดัะฒะฐัััั ะบะพะต-ะบะฐะบะธะต ัะพะผะฝะตะฝะธั ะธ ะฟะพะดะพะทัะตะฝะธั
rus_verbs:ะดััั{},
rus_verbs:ะะะะะขะะขะฌ{}, //
rus_verbs:ะ ะะะะะะะขะะขะฌ{}, //
rus_verbs:ะะะะ ะะกะขะะขะฌ{}, //
rus_verbs:ะะะะ ะะกะขะ{}, //
rus_verbs:ะะะะะฏะขะฌ{}, // ะะฝ ะฟะพะดะฝัะป ะฟะพะปะพะฒะธะฝะบั ัะฐะผะพะปะตัะฐ ะฒ ะฒะพะทะดัั
ะธ ะฝะฐ ะฒัะตะน ัะบะพัะพััะธ ะฟะพะฒะตะป ะตะต ะบ ะณะพัะฐะผ. (ะะะะะฏะขะฌ)
rus_verbs:ะะขะะะขะะขะฌะกะฏ{}, // ะฃัะปััะฐะฒ ะทะฐ ัะฟะธะฝะพะน ะดัั
ะฐะฝะธะต, ะพะฝ ะฟััะณะฝัะป ะฒะฟะตัะตะด ะธ ะพัะบะฐัะธะปัั ะฒ ััะพัะพะฝั, ัะฐัััะธััะฒะฐั ััะบะพะปัะทะฝััั ะพั ะฒัะฐะณะฐ, ะฝะฐะฟะฐะดะฐะฒัะตะณะพ ัะทะฐะดะธ (ะะขะะะขะะขะฌะกะฏ)
rus_verbs:ะะะะะขะะขะฌะกะฏ{}, // ะ ะพะฑัะธะน ัะผัะฐะด ะฒะฟะปะตัะฐะปะพัั ะทะปะพะฒะพะฝัะต ะฟะตะฝั, ะปะตัะตะฒัะตะน ะธะท ะฟะฐััะตะน, ะธ ะบัะพะฒะธ ะธะท ะปะตะณะบะธั
(ะะะะะขะะขะฌะกะฏ)
rus_verbs:ะะะะะะะขะฌ{}, // ะะฝะธ ะฟะพะดัะผะฐะปะธ, ััะพ ะะฐะฒะตะป ะฟััะฐะตััั ะทะฐะผะฐะฝะธัั ะธั
ะฒ ะทะพะฝั ะพะฑัััะตะปะฐ. (ะะะะะะะขะฌ,ะะะะะะะะะขะฌ)
rus_verbs:ะะะะะะะะะขะฌ{},
rus_verbs:ะะ ะะขะ ะฃะะะขะฌ{}, // ะญัะธ ะฒัะฐัะฐ ะพัะบัะพัััั, ะบะพะณะดะฐ ะพะฝ ะฟัะพัััะฑะธั ะฒ ัะพะณ, ะธ ะฟัะพะฟััััั ะตะณะพ ะฒ ะดััะณัั ะฒัะตะปะตะฝะฝัั. (ะะ ะะขะ ะฃะะะขะฌ)
rus_verbs:ะะ ะฃะะะขะฌะกะฏ{}, // ะะปะธะฝะพะบ ัะปะพะผะฐะปัั, ะฝะต ะฒััะฑะธะฒัะธัั ะฒ ะผะตัะฐะปะป. (ะะ ะฃะะะขะฌะกะฏ/ะะ ะฃะะะขะฌะกะฏ)
rus_verbs:ะะ ะฃะะะขะฌะกะฏ{},
rus_verbs:ะะขะะ ะะะะขะฌ{}, // ะั ะธัะตะผ ะฑะปะฐะณะพัะพะดะฝะพะณะพ ะฒะตะปัะผะพะถั, ะบะพัะพััะน ะฝะฐะฝัะป ะฑั ะฝะฐั ะธะปะธ ะพัะฟัะฐะฒะธะป ะฒ ัััะฐััะบะธะน ะฟะพะธัะบ. (ะะขะะ ะะะะขะฌ)
rus_verbs:ะะะะะงะะขะฌ{}, // ะญัะพั ะฑัะป ะพะฑะปะฐัะตะฝ ะฒ ัะฒะตัะบะฐะฒัะธะต ะบัะฐัะฝัะต ะดะพัะฟะตั
ะธ ั ะพะฟััะตะฝะฝัะผ ะทะฐะฑัะฐะปะพะผ ะธ ะดะตัะถะฐะป ะพะณัะพะผะฝะพะต ะบะพะฟัะต, ะดะพะถะธะดะฐััั ัะฒะพะตะน ะพัะตัะตะดะธ. (ะะะะะงะะขะฌ/ะะะะะงะะขะฌ/ะะะะะงะะขะฌะกะฏ/ะะะะะงะะขะฌะกะฏ/ะะะ ะฏะะะขะฌะกะฏ/ะะะ ะฏะะะขะฌะกะฏ)
rus_verbs:ะะะะะงะะขะฌ{},
rus_verbs:ะะะะะงะะขะฌะกะฏ{},
rus_verbs:ะะะะะงะะขะฌะกะฏ{},
rus_verbs:ะะะ ะฏะะะขะฌะกะฏ{},
rus_verbs:ะะะ ะฏะะะขะฌะกะฏ{},
rus_verbs:ะะะฅะะะขะะขะฌ{}, // ะัะพะผะต ะฝะฐะฑัะฐะฝะฝะพะณะพ ัะฐะฑัะบะพะณะพ ะผะฐัะตัะธะฐะปะฐ ะพะฑััะฝะพะณะพ ัะธะฟะฐ, ะพะฝ ะทะฐั
ะฒะฐัะธะป ะฒ ะฟะปะตะฝ ะณััะฟะฟั ะพัะตะฝั ัััะฐะฝะฝัั
ัะพะทะดะฐะฝะธะน, ะฐ ัะฐะบะถะต ะถะตะฝัะธะฝั ะธัะบะปััะธัะตะปัะฝะพะน ะบัะฐัะพัั (ะะะฅะะะขะะขะฌ/ะะะฅะะะขะซะะะขะฌ/ะะะฅะะะข)
rus_verbs:ะะะฅะะะขะซะะะขะฌ{},
rus_verbs:ะะ ะะะะกะขะ{}, // ะะฝ ะฟัะพะฒะตะป ะธั
ะฒ ะผะฐะปะตะฝัะบะพะต ัะฒััะธะปะธัะต ะฟะพะทะฐะดะธ ััััะฒะฐะปะฐ. (ะะ ะะะะกะขะ)
rus_verbs:ะะะะะะขะฌ{}, // ะั
ะผะพะถะฝะพ ะฟะพะนะผะฐัั ะฒ ะปะพะฒััะบั (ะะะะะะขะฌ)
rus_verbs:ะกะขะ ะะะขะฌะกะฏ{}, // ะะฐ ะฒะตััะธะฝะต ะพะฝะธ ะพััะฐะฝะพะฒะธะปะธัั, ัััะพััั ะฒ ะบััะณ. (ะกะขะ ะะะขะฌะกะฏ,ะะะกะขะ ะะะขะฌะกะฏ,ะะซะกะขะ ะะะขะฌะกะฏ)
rus_verbs:ะะะกะขะ ะะะขะฌะกะฏ{},
rus_verbs:ะะซะกะขะ ะะะขะฌะกะฏ{},
rus_verbs:ะะซะะฃะกะขะะขะฌ{}, // ะะตัะบะพะปัะบะพ ัััะตะป, ะฒัะฟััะตะฝะฝัั
ะฒ ะฟัะตัะปะตะดัะตะผัั
, ะฒะพะฝะทะธะปะธัั ะฒ ััะฐะฒั (ะะซะะฃะกะขะะขะฌ/ะะซะะฃะกะะะขะฌ)
rus_verbs:ะะซะะฃะกะะะขะฌ{},
rus_verbs:ะะฆะะะะฏะขะฌะกะฏ{}, // ะะฝะธ ะฒัะตะฟะปััััั ัะตะฑะต ะฒ ะณะพัะปะพ. (ะะฆะะะะฏะขะฌะกะฏ/ะะฆะะะะขะฌะกะฏ)
rus_verbs:ะะฆะะะะขะฌะกะฏ{},
rus_verbs:ะะะะฌะะฃะขะฌ{}, // ะะพะปัั ะฒััะฐะฒะธะป ะฒ ัะตัะธะฒั ะฝะพะฒัั ัััะตะปั ะธ ะฟะฐะปัะฝัะป ะฒ ะฑะตะปะพะต ะฑััั
ะพ (ะะะะฌะะฃะขะฌ)
rus_verbs:ะะขะกะขะฃะะะขะฌ{}, // ะะพะปัั ะพััััะฟะธะป ะฒ ัะตะปั. (ะะขะกะขะฃะะะขะฌ/ะะขะกะขะฃะะะขะฌ)
rus_verbs:ะะขะกะขะฃะะะขะฌ{},
rus_verbs:ะะ ะะะะฃะขะฌ{}, // ะะพะปัั ะบัะธะบะฝัะป ะฒ ะพัะฒะตั ะธ ะผะตะดะปะตะฝะฝะพ ะพััััะฟะธะป ะพั ะฟัะธัั. (ะะ ะะะะฃะขะฌ)
rus_verbs:ะะซะฅะะฃะขะฌ{}, // ะ ะปะธัะพ ะตะผั ะดัั
ะฝัะปะธ ะฒะธะฝะฝัะผ ะฟะตัะตะณะฐัะพะผ. (ะะซะฅะะฃะขะฌ)
rus_verbs:ะะะขะ ะฃะะะขะฌ{}, // ะฏ ะฒะธะดะตะป ัะพะณ ะฒะพ ะฒัะตะผั ัะฒะพะธั
ัะบะธัะฐะฝะธะน ะฟะพ ะดะฒะพััั ะธ ะดะฐะถะต ะฟะพัััะฑะธะป ะฒ ะฝะตะณะพ (ะะะขะ ะฃะะะขะฌ)
rus_verbs:ะะขะะ ะซะะะขะฌะกะฏ{}, // ะะตะบะพัะพััะต ะฒัะฐัะฐ ะพัะบััะฒะฐะปะธัั ะฒ ะดััะณะธะต ะฒัะตะปะตะฝะฝัะต (ะะขะะ ะซะะะขะฌะกะฏ)
rus_verbs:ะขะ ะฃะะะขะฌ{}, // ะ ั ัััะฑะธะป ะฒ ัะพะณ (ะขะ ะฃะะะขะฌ)
rus_verbs:ะะซะ ะะฃะขะฌ{}, // ะะพะปัั ะฟััะฝัะป ะตะณะพ ะฒ ะฑะพะบ. (ะะซะ ะะฃะขะฌ)
rus_verbs:ะะ ะะกะะ ะะะะขะะขะฌ{}, // ะขะพั ััะพ-ัะพ ะฟัะพัะบัะตะถะตัะฐะป ะฒ ะพัะฒะตั, ะฐ ะทะฐัะตะผ ะฝะฐะพัะฐะป ะฝะฐ ะฝะตะณะพ. (ะะ ะะกะะ ะะะะขะะขะฌ ะ ะฒะธะฝ, ะะะะ ะะขะฌ ะะ ะฒะธะฝ)
rus_verbs:ะะะะะ ะขะะ ะะะะขะฌ{}, // ะธะผะฟะพััะธัะพะฒะฐัั ัะพะฒะฐัั ะดะฒะพะนะฝะพะณะพ ะฟัะธะผะตะฝะตะฝะธั ัะพะปัะบะพ ะฒ ะ ะพััะธะนัะบัั ะคะตะดะตัะฐัะธั (ะะะะะ ะขะะ ะะะะขะฌ)
rus_verbs:ะะขะชะะฅะะขะฌ{}, // ะะตะณะบะธะน ะณัะพั
ะพั ะบะฐัะบะพะฒ ะทะฐะณะปััะธะป ัะพะณ, ะบะพะณะดะฐ ะดะฒะตัั ะพััะตั
ะฐะปะฐ ะฒ ััะพัะพะฝั. (ะะขะชะะฅะะขะฌ)
rus_verbs:ะะะะะะกะขะะกะฌ{}, // ะะพะดะพะฑัะฐะฒ ะฝะธะถะฝะตะต ะฑะตะปัะต, ะฝะพัะบะธ ะธ ะฑะพัะธะฝะบะธ, ะพะฝ ะฟะพะฟะปะตะปัั ะฟะพ ะฟะตัะบั ะพะฑัะฐัะฝะพ ะฒ ะดะถัะฝะณะปะธ. (ะะะะะะะกะฏ)
rus_verbs:ะกะะะขะฌะกะฏ{}, // ะะตะปัะดะพะบ ั ะฝะตะณะพ ัะถะฐะปัั ะฒ ะบัะปะฐะบ. (ะกะะะขะฌะกะฏ, ะกะะะะะขะฌะกะฏ)
rus_verbs:ะกะะะะะขะฌะกะฏ{},
rus_verbs:ะฟัะพะฒะตัััั{}, // ะจะบะพะปัะฝะธะบะพะฒ ะฑัะดัั ะฟัะธะฝัะดะธัะตะปัะฝะพ ะฟัะพะฒะตัััั ะฝะฐ ะบััะตะฝะธะต
rus_verbs:ะะะขะฏะะฃะขะฌ{}, // ะฏ ะฟะพััะฝัะป ะตะณะพ ะฒ ะบะธะฝะพ (ะะะขะฏะะฃะขะฌ)
rus_verbs:ะะะ ะะะะกะขะ{}, // ะัะตะผัะตั-ะผะธะฝะธััั ะะฐะทะฐั
ััะฐะฝะฐ ะฟะพัััะธะป ะดะพ ะบะพะฝัะฐ ะณะพะดะฐ ะฟะตัะตะฒะตััะธ ะฒัะต ัะพัะธะฐะปัะฝะพ-ะทะฝะฐัะธะผัะต ััะปัะณะธ ะฒ ัะปะตะบััะพะฝะฝัะน ะฒะธะด (ะะะ ะะะะกะขะ)
rus_verbs:ะะ ะะกะะขะฌ{}, // ะะพัะตะผั ะบะธัะฐะนัะบะธะต ะฟะฐััะธะนะฝัะต ะฑะพััั ะบัะฐััั ะฒะพะปะพัั ะฒ ัะตัะฝัะน ัะฒะตั? (ะะ ะะกะะขะฌ/ะะะะ ะะกะะขะฌ/ะะะ ะะะ ะะกะะขะฌ/ะะะ ะะกะะขะฌ/ะะะะ ะะกะะขะฌ)
rus_verbs:ะะะะ ะะกะะขะฌ{}, //
rus_verbs:ะะะ ะะะ ะะกะะขะฌ{}, //
rus_verbs:ะะะ ะะกะะขะฌ{}, //
rus_verbs:ะะะะ ะะกะะขะฌ{}, //
rus_verbs:ะกะะะะฉะะขะฌ{}, // ะัะถัะธะฝะฐ ัะฐะฝะธะป ัะตะปะพะฒะตะบะฐ ะฒ ัะตะบั ะธ ัะฐะผ ัะพะพะฑัะธะป ะพะฑ ััะพะผ ะฒ ะฟะพะปะธัะธั (ะกะะะะฉะะขะฌ)
rus_verbs:ะกะขะฏะะะะะขะฌ{}, // ะะพ ัะพะปัะธะฝะฐ ะฟัะทััั ะฟะพััะพัะฝะฝะพ ะผะตะฝัะตััั ะธะท-ะทะฐ ะณัะฐะฒะธัะฐัะธะธ, ะบะพัะพัะฐั ัััะณะธะฒะฐะตั ะถะธะดะบะพััั ะฒ ะฝะธะถะฝัั ัะฐััั (ะกะขะฏะะะะะขะฌ/ะกะขะฏะะฃะขะฌ/ะะะขะฏะะฃะขะฌ/ะะขะฏะะฃะขะฌ)
rus_verbs:ะกะขะฏะะฃะขะฌ{}, //
rus_verbs:ะะะขะฏะะฃะขะฌ{}, //
rus_verbs:ะะขะฏะะฃะขะฌ{}, //
rus_verbs:ะกะะฅะ ะะะะขะฌ{}, // ัะพั
ัะฐะฝะธัั ะดะฐะฝะฝัะต ะฒ ัะฐะนะป (ะกะะฅะ ะะะะขะฌ)
ะดะตะตะฟัะธัะฐััะธะต:ะฟัะธะดั{}, // ะะตะผะฝะพะณะพ ะฟัะธะดั ะฒ ัะตะฑั
rus_verbs:ะฝะฐะฑะปัะดะฐัั{}, // ะกัะดัั , ะดะพะปะณะพ ะฝะฐะฑะปัะดะฐะฒัะธะน ะฒ ัััะฑั , ะฒะดััะณ ะฒัะบัะธัะฐะป
rus_verbs:ะฃะะซะะะขะฌะกะฏ{}, // ะพะฝะฐ ัะปัะฑะฐะปะฐัั ะฒะพ ะฒะตัั ัะพั (ะฃะะซะะะขะฌะกะฏ)
rus_verbs:ะะะขะะฃะขะฌะกะฏ{}, // ะพะฝะฐ ะผะตัะฝัะปะฐัั ะพะฑัะฐัะฝะพ ะฒะพ ััะผั (ะะะขะะฃะขะฌะกะฏ)
rus_verbs:ะะะกะะะะะะะขะฌ{}, // ะฑะพะปััะธะฝััะฒะพ ะถะธัะตะปะตะน ะณะพัะพะดะฐ ะฟะพัะปะตะดะพะฒะฐะปะพ ะทะฐ ะฝะธะผ ะฒะพ ะดะฒะพัะตั (ะะะกะะะะะะะขะฌ)
rus_verbs:ะะะ ะะะะฉะะขะฌะกะฏ{}, // ัะบัััะตะผะธััั ะฟะตัะตะผะตัะฐัััั ะธะท ะปะตัะพะฒ ะฒ ะกะตัั (ะะะ ะะะะฉะะขะฌะกะฏ)
rus_verbs:ะะซะขะะฉะะขะฌ{}, // ะะปะตะบัะตะน ะฟะพะทะฒะพะปะธะป ะฒััะฐัะธัั ัะตะฑั ัะตัะตะท ะดะฒะตัั ะฒะพ ััะผั (ะะซะขะะฉะะขะฌ)
rus_verbs:ะกะซะะะขะฌะกะฏ{}, // ะฒะฝะธะทั ะฟะพะด ะฝะธะผะธ ะบะฐะผะฝะธ ะณัะฐะดะพะผ ััะฟะฐะปะธัั ะฒะพ ะดะฒะพั (ะกะซะะะขะฌะกะฏ)
rus_verbs:ะฒัะตะทะถะฐัั{}, // ะทะฐะบะปััะตะฝะฝัะต ัะฐะผะธ ัััั ะบัะบะปั ะธ ะธะฝะพะณะดะฐ ะฒัะตะทะถะฐัั ั ะฟัะตะดััะฐะฒะปะตะฝะธัะผะธ ะฒ ะดะตััะบะธะน ะดะพะผ ะฝะตะฟะพะดะฐะปะตะบั
rus_verbs:ะะ ะะงะะขะฌ{}, // ะตะน ั
ะพัะตะปะพัั ะบัะธัะฐัั ะฒะพ ะฒะตัั ะณะพะปะพั (ะะ ะะงะะขะฌ ะ ะฒะธะฝ)
rus_verbs:ะะซะะ ะฏะะะขะฌะกะฏ{}, // ะฒะพะปะบ ะฒัะฟััะผะธะปัั ะฒะพ ะฒะตัั ะพะณัะพะผะฝัะน ัะพัั (ะะซะะ ะฏะะะขะฌะกะฏ ะ ะฒะธะฝ)
rus_verbs:ัะฟัััะฐัั{}, // ะะถะพะฝ ัะฟัััะฐะป ะพัะบะธ ะฒะพ ะฒะฝัััะตะฝะฝะธะน ะบะฐัะผะฐะฝ (ัะฟัััะฐัั ะฒ ะฒะธะฝ)
rus_verbs:ะญะะกะขะ ะะะะ ะะะะขะฌ{}, // ะฃะบัะฐะธะฝะฐ ัะบัััะฐะดะธััะตั ะฒ ะขะฐะดะถะธะบะธััะฐะฝ ะทะฐะดะตัะถะฐะฝะฝะพะณะพ ะฑัะฒัะตะณะพ ะฟัะตะผัะตั-ะผะธะฝะธัััะฐ (ะญะะกะขะ ะะะะ ะะะะขะฌ ะ ะฒะธะฝ)
rus_verbs:ะะะะะะขะฌ{}, // ะปะฐะฑะพัะฐัะพัะฝัะน ะผะพะฝะธัะพัะธะฝะณ ะฒะฒะพะทะธะผะพะน ะฒ ะ ะพััะธั ะผััะฝะพะน ะฟัะพะดัะบัะธะธ ะธะท ะกะจะ (ะะะะะะขะฌ ะ ะฒะธะฝ)
rus_verbs:ะฃะะะะะะะขะฌ{}, // ัะฟะฐะบะพะฒะฐะฝะฝัั
ะฒ ะฝะตัะบะพะปัะบะพ ัะปะพะตะฒ ะฟะพะปะธััะธะปะตะฝะฐ (ะฃะะะะะะะขะฌ ะ ะฒะธะฝ)
rus_verbs:ะะขะขะฏะะะะะขะฌ{}, // ะธัะฟะพะปัะทะพะฒะฐัั ะตััะตััะฒะตะฝะฝัั ัะธะปั ะณัะฐะฒะธัะฐัะธะธ, ะพัััะณะธะฒะฐั ะพะฑัะตะบัั ะฒ ััะพัะพะฝั ะธ ะธะทะผะตะฝัั ะธั
ะพัะฑะธัั (ะะขะขะฏะะะะะขะฌ ะ ะฒะธะฝ)
rus_verbs:ะะะะะะะะขะฌ{}, // ะพะฝะธ ะฟะพะทะฒะพะฝะธะปะธ ะฒ ะพัะดะตะป ัะบะพะปะพะณะธะธ ะณะพัะพะดัะบะพะน ะฐะดะผะธะฝะธัััะฐัะธะธ (ะะะะะะะะขะฌ ะ)
rus_verbs:ะะ ะะะะะงะฌ{}, // ะัะบัััะพััั ะดะฐะฝะฝัั
ะพ ะปะตัะต ะฟะพะผะพะถะตั ะฟัะธะฒะปะตัั ะธะฝะฒะตััะธัะธะธ ะฒ ะพััะฐัะปั (ะะ ะะะะะงะฌ ะ)
rus_verbs:ะะะะ ะะกะะขะฌะกะฏ{}, // ะฝะฐะฑะตะณะฐะฒัะธัั ะธ ะฝะฐะฟะปััะฐะฒัะธัั, ะกัะฐัะธะบ ััะพะผะธะปัั ะธ ะทะฐะฟัะพัะธะปัั ะฒ ะบัะพะฒะฐัะบั (ะะะะ ะะกะะขะฌะกะฏ ะ)
rus_verbs:ะะขะกะขะะะะขะฌ{}, // ะฑัััะปั ั ะฐัะตัะพะฝะพะผ ะะธััะบะฐ ะพัััะฐะฒะธะป ะฒ ััะพัะพะฝะบั (ะะขะกะขะะะะขะฌ ะ)
rus_verbs:ะะกะะะะฌะะะะะขะฌ{}, // ัั ะธัะฟะพะปัะทะพะฒะฐะป ัะฒะพั ะผะฐะณะธั ะฒะพ ะทะปะพ. (ะะกะะะะฌะะะะะขะฌ ะ ะฒะธะฝ)
rus_verbs:ะะซะกะะะะขะฌ{}, // ะ ะฐะฟัะตะปะต ัะตะดะธั ะฒะพะทะผะพะถะฝะพ ัะถะต ะฒััะตะฒะฐัั ะฒ ะณััะฝั (ะะซะกะะะะขะฌ ะ)
rus_verbs:ะะะะะะขะฌ{}, // ะะผะตัะธะบะฐะฝัะบะธะน ะฟัะธั
ะพะปะพะณ ะทะฐะณะฝะฐะป ะปัะฑะพะฒั ะฒ ััะธ ัะณะปะฐ (ะะะะะะขะฌ ะ)
rus_verbs:ะญะะะะฎะฆะะะะะ ะะะะขะฌ{}, // ะะพัะตะผั ะฝะต ะฒัะต ะพะฑะตะทััะฝั ัะฒะพะปััะธะพะฝะธัะพะฒะฐะปะธ ะฒ ัะตะปะพะฒะตะบะฐ? (ะญะะะะฎะฆะะะะะ ะะะะขะฌ ะ ะฒะธะฝ)
rus_verbs:ะกะคะะขะะะ ะะคะะ ะะะะขะฌะกะฏ{}, // ะะฝ ััะพัะพะณัะฐัะธัะพะฒะฐะปัั ะฒะพ ะฒะตัั ัะพัั. (ะกะคะะขะะะ ะะคะะ ะะะะขะฌะกะฏ ะ)
rus_verbs:ะกะขะะะะขะฌ{}, // ะะฝ ััะฐะฒะธั ะผะฝะต ะฒ ัะฟััะบ ัะฒะพั ะพัะธะฑะบั. (ะกะขะะะะขะฌ ะ)
rus_verbs:ัะฐััะตะฟะปััััั{}, // ะกะฐั
ะฐัะพะทะฐ ะถะต ะฑััััะพ ัะฐััะตะฟะปัะตััั ะฒ ะฟะธัะตะฒะฐัะธัะตะปัะฝะพะผ ััะฐะบัะต ะฝะฐ ะณะปัะบะพะทั ะธ ัััะบัะพะทั (ะ ะะกะฉะะะะฏะขะฌะกะฏ ะ, ะะ)
rus_verbs:ะะะ ะะกะะะฏะขะฌะกะฏ{}, // ะัะตะบะธ ะฟะตัะตัะตะปััััั ะฒ ะะตัะผะฐะฝะธั (ะะะ ะะกะะะฏะขะฌะกะฏ ะ)
rus_verbs:ะคะะ ะะะ ะะะะขะฌะกะฏ{}, // ะกะฐั
ะฐัะฝะฐั ัะฒะตะบะปะฐ ะพัะฝะพัะธััั ะบ ะดะฒัะปะตัะฝะธะผ ัะฐััะตะฝะธัะผ, ะผััะธัััะน ะบะพัะฝะตะฟะปะพะด ัะพัะผะธััะตััั ะฒ ะฟะตัะฒัะน ะณะพะด. (ะคะะ ะะะ ะะะะขะฌะกะฏ ะ)
rus_verbs:ะะ ะะะะ ะงะะขะฌ{}, // ะดะตะดัะปั ััะพ-ัะพ ะฟัะพะฒะพััะฐะป ะฒ ะพัะฒะตั (ะะ ะะะะ ะงะะขะฌ ะ)
rus_verbs:ะะฃะ ะะะฃะขะฌ{}, // ะฝะตะปัะดะธะผัะน ะฟะฐัะตะฝั ััะพ-ัะพ ะฑััะบะฝัะป ะฒ ะพัะฒะตั (ะะฃะ ะะะฃะขะฌ ะ)
rus_verbs:ะะะกะขะ{}, // ะดะฒะตัั ะฒะตะปะฐ ะฒะพ ััะผั. (ะะะกะขะ ะ)
rus_verbs:ะะซะกะะะงะะขะฌ{}, // ะฑะตะณะปะตัั ะฒััะบะพัะธะปะธ ะฒะพ ะดะฒะพั. (ะะซะกะะะงะะขะฌ ะ)
rus_verbs:ะะะกะซะะะขะฌ{}, // ะะดะฝะธะผ ะดะฒะธะถะตะฝะธะตะผ ัััะตะปะพะบ ะดะพััะปะฐะตั ะฟะฐััะพะฝ ะฒ ััะฒะพะป (ะะะกะซะะะขะฌ ะ)
rus_verbs:ะกะชะะฅะะขะฌะกะฏ{}, // ะคะธะฝะฐะปะธััั ััะตั
ะฐะปะธัั ะฝะฐ ัะฒะพะธ ะธะณัั ะฒ ะะพั-ะะฝะถะตะปะตั. (ะกะชะะฅะะขะฌะกะฏ ะะ, ะ)
rus_verbs:ะะซะขะฏะะฃะขะฌ{}, // ะัะผ ะฒัััะฝัะปะพ ะฒ ัััะฑั. (ะะซะขะฏะะฃะขะฌ ะ)
rus_verbs:ัะพััะฐัั{}, // ะพััััะต ะพะฑะปะพะผะบะธ ะฑัะตะฒะตะฝ ัะพััะฐะปะธ ะฒะพ ะฒัะต ััะพัะพะฝั.
rus_verbs:ะะะะฏะะซะะะขะฌ{}, // ะะฝะฐ ะพะณะปัะดัะฒะฐะตั ัะตะฑั ะฒ ะทะตัะบะฐะปะพ. (ะะะะฏะะซะะะขะฌ ะ)
rus_verbs:ะะะะกะขะะะะะขะฌ{}, // ะญัะพั ะฟะฐะบะตั ะทะฐะบะพะฝะพะฒ ะดะตะนััะฒัะตั ะฒ ััะตัะฑ ัะฐััะฝัะผ ะฟัะตะดะฟัะธะฝะธะผะฐัะตะปัะผ.
rus_verbs:ะ ะะะะะขะะขะฌะกะฏ{}, // ะปัะดะธ ัะฐะทะปะตัะตะปะธัั ะฒะพ ะฒัะต ััะพัะพะฝั. (ะ ะะะะะขะะขะฌะกะฏ ะ)
rus_verbs:ะฑััะทะฝััั{}, // ะฒะพ ะฒัะต ััะพัะพะฝั ะฑััะทะฝัะปะฐ ะบัะพะฒั. (ะฑััะทะฝััั ะฒ)
rus_verbs:ะขะฏะะฃะขะฌะกะฏ{}, // ะฟัะพะฒะพะดะฐ ััะฝัะปะธัั ะฒะพ ะฒัะต ัะณะปั. (ะขะฏะะฃะขะฌะกะฏ ะ)
rus_verbs:ะฒะฐะปะธัั{}, // ะฒะฐะปะธัั ะฒัะต ะฒ ะพะดะฝั ะบััั (ะฒะฐะปะธัั ะฒ)
rus_verbs:ะฒัะดะฒะธะฝััั{}, // ะตะณะพ ะฒัะดะฒะธะฝัะปะธ ะฒ ะฟะฐะปะฐัั ะฟัะตะดััะฐะฒะธัะตะปะตะน (ะฒัะดะฒะธะฝััั ะฒ)
rus_verbs:ะบะฐัะฐะฑะบะฐัััั{}, // ะบะฐัะฐะฑะบะฐัััั ะฒ ะณะพัั (ะบะฐัะฐะฑะบะฐัััั ะฒ)
rus_verbs:ะบะปะพะฝะธัััั{}, // ะพะฝ ะบะปะพะฝะธะปัั ะฒ ััะพัะพะฝั (ะบะปะพะฝะธัััั ะฒ)
rus_verbs:ะบะพะผะฐะฝะดะธัะพะฒะฐัั{}, // ะผั ะบะพะผะฐะฝะดะธัะพะฒะฐะปะธ ะฝะฐัะตะณะพ ะฟัะตะดััะฐะฒะธัะตะปั ะฒ ะ ะธะผ (ะบะพะผะฐะฝะดะธัะพะฒะฐัั ะฒ)
rus_verbs:ะทะฐะฟะฐััั{}, // ะญัะธ ัะปะพะฒะฐ ะทะฐะฟะฐะปะธ ะผะฝะต ะฒ ะดััั.
rus_verbs:ะดะฐะฒะฐัั{}, // ะ ััะพะน ะปะฐะฒะบะต ะดะฐัั ะฒ ะดะพะปะณ?
rus_verbs:ะตะทะดะธัั{}, // ะะฐะถะดัะน ะดะตะฝั ะณััะทะพะฒะธะบ ะตะทะดะธั ะฒ ะณะพัะพะด.
rus_verbs:ะฟัะตัะฒะพัะธัััั{}, // ะะฐะผััะตะป ะฟัะตัะฒะพัะธะปัั ะฒ ะถะธะทะฝั.
rus_verbs:ัะฐะทะพะนัะธัั{}, // ะะฝะธ ัะฐะทะพัะปะธัั ะฒ ัะฐะทะฝัะต ััะพัะพะฝั.
rus_verbs:ะฒัะนัะธ{}, // ะั
ะพัะฝะธะบ ะฒััะตะป ะฒ ะฟะพะปะต ั ััะถััะผ.
rus_verbs:ะพัะพะทะฒะฐัั{}, // ะัะทะพะฒะธัะต ะตะณะพ ะฒ ััะพัะพะฝั ะธ ัะบะฐะถะธัะต ะตะผั ะพะฑ ััะพะผ.
rus_verbs:ัะฐัั
ะพะดะธัััั{}, // ะะฐัะฐ ะธ ะะตัั ัะฐัั
ะพะดัััั ะฒ ัะฐะทะฝัะต ััะพัะพะฝั
rus_verbs:ะฟะตัะตะพะดะตะฒะฐัััั{}, // ะฟะตัะตะพะดะตะฒะฐัััั ะฒ ะถะตะฝัะบะพะต ะฟะปะฐััะต
rus_verbs:ะฟะตัะตัะฐััะฐัั{}, // ะฟะตัะตัะฐััะฐัั ะฒ ะผะฐััะพะฒัะต ะฑะตัะฟะพััะดะบะธ
rus_verbs:ะทะฐะฒัะทัะฒะฐัััั{}, // ะทะฐะฒัะทัะฒะฐัััั ะฒ ัะทะตะป
rus_verbs:ะฟะพั
ะฒะฐัะฐัั{}, // ะฟะพั
ะฒะฐัะฐัั ะฒ ััะบะธ
rus_verbs:ัะฒะปะตัั{}, // ัะฒะปะตัั ะฒ ะฟัะพะณัะปะบั ะฟะพ ะฟะฐัะบั
rus_verbs:ะฟะพะผะตัะฐัั{}, // ะฟะพะผะตัะฐัั ะฒ ะธะทะพะปััะพั
rus_verbs:ะทััะบะฝััั{}, // ะทััะบะฝััั ะฒ ะพะบะพัะบะพ
rus_verbs:ะทะฐะบะฐัะฐัั{}, // ะทะฐะบะฐัะฐัั ะฒ ะฐััะฐะปัั
rus_verbs:ััะฐะถะธะฒะฐัััั{}, // ััะฐะถะธะฒะฐัััั ะฒ ะบัะตัะปะพ
rus_verbs:ะทะฐะณะพะฝััั{}, // ะทะฐะณะพะฝััั ะฒ ัะฐัะฐะน
rus_verbs:ะฟะพะดะฑัะฐััะฒะฐัั{}, // ะฟะพะดะฑัะฐััะฒะฐัั ะฒ ะฒะพะทะดัั
rus_verbs:ัะตะปะตะณัะฐัะธัะพะฒะฐัั{}, // ัะตะปะตะณัะฐัะธัะพะฒะฐัั ะฒ ัะตะฝัั
rus_verbs:ะฒัะทะฐัั{}, // ะฒัะทะฐัั ะฒ ััะพะฟั
rus_verbs:ะฟะพะดะปะธัั{}, // ะฟะพะดะปะธัั ะฒ ะพะณะพะฝั
rus_verbs:ะทะฐะฟะพะปััะธัั{}, // ะทะฐะฟะพะปััะธัั ะฒ ัะฐัะฟะพััะถะตะฝะธะต
rus_verbs:ะฟะพะดะพะณะฝะฐัั{}, // ะฟะพะดะพะณะฝะฐัั ะฒ ะดะพะบ
rus_verbs:ะปะพะผะธัััั{}, // ะปะพะผะธัััั ะฒ ะพัะบััััั ะดะฒะตัั
rus_verbs:ะฟะตัะตะฟัะฐะฒะธัั{}, // ะฟะตัะตะฟัะฐะฒะธัั ะฒ ะดะตัะตะฒะฝั
rus_verbs:ะทะฐััะณะธะฒะฐัััั{}, // ะทะฐััะณะธะฒะฐัััั ะฒ ัััะฑั
rus_verbs:ัะฐะทะปะตัะฐัััั{}, // ัะฐะทะปะตัะฐัััั ะฒ ััะพัะพะฝั
rus_verbs:ะบะปะฐะฝััััั{}, // ะบะปะฐะฝััััั ะฒ ะฝะพะถะบะธ
rus_verbs:ััััะตะผะปััััั{}, // ััััะตะผะปััััั ะฒ ะพัะบัััะพะต ะผะพัะต
rus_verbs:ะฟะตัะตะผะตััะธัััั{}, // ะฟะตัะตะผะตััะธัััั ะฒ ะดััะณัั ะฐัะดะธัะพัะธั
rus_verbs:ะปะพะถะธัั{}, // ะปะพะถะธัั ะฒ ััะธะบ
rus_verbs:ะพัะฒะพะทะธัั{}, // ะพัะฒะพะทะธัั ะฒ ะฐััะพะฟะพัั
rus_verbs:ะฝะฐะฟัะฐัะธะฒะฐัััั{}, // ะฝะฐะฟัะฐัะธะฒะฐัััั ะฒ ะณะพััะธ
rus_verbs:ะฝะฐะฟัะพัะธัััั{}, // ะฝะฐะฟัะพัะธัััั ะฒ ะณะพััะธ
rus_verbs:ะฝะฐะณััะฝััั{}, // ะฝะฐะณััะฝััั ะฒ ะณะพััะธ
rus_verbs:ะทะฐะฒะพัะฐัะธะฒะฐัั{}, // ะทะฐะฒะพัะฐัะธะฒะฐัั ะฒ ัะพะปัะณั
rus_verbs:ะทะฐะบะพะฒะฐัั{}, // ะทะฐะบะพะฒะฐัั ะฒ ะบะฐะฝะดะฐะปั
rus_verbs:ัะฒะตะทัะธ{}, // ัะฒะตะทัะธ ะฒ ัะฐัะฐะน
rus_verbs:ะฟัะธัะฐัะธัััั{}, // ะฟัะธัะฐัะธัััั ะฒ ะดะพะผ
rus_verbs:ะทะฐะฒะตัะฑะพะฒะฐัั{}, // ะทะฐะฒะตัะฑะพะฒะฐัั ะฒ ัะฐะทะฒะตะดะบั
rus_verbs:ััะฑะธัััั{}, // ััะฑะธัััั ะฒ ะบะพะผะฟัััะตัะฝัะต ะธะณัั
rus_verbs:ััะบะฐัััั{}, // ััะบะฐัััั ะฒ ะผะฐัะตัะธะฝัะบัั ะณััะดั
ะธะฝัะธะฝะธัะธะฒ:ัััะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ัััะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ัััะฟะฐัั ะฒ ะบะพะฝัะตะนะฝะตั
ะณะปะฐะณะพะป:ัััะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัััะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ัััะฟะฐะฒ{}, ะดะตะตะฟัะธัะฐััะธะต:ัััะฟะฐั{},
rus_verbs:ะทะฐัะฐััะฒะฐัั{}, // ะทะฐัะฐััะฒะฐัั ะฒ ัะตะฑั
rus_verbs:ัะบะฐะบะฝััั{}, // ัะบะฐะบะฝััั ะฒ ะฑัะดััะตะต
rus_verbs:ะฟะพะดะฒะพะทะธัั{}, // ะฟะพะดะฒะพะทะธัั ะฒ ัะตะฐัั
rus_verbs:ะฟะตัะตะธะณัะฐัั{}, // ะฟะตัะตะธะณัะฐัั ะฒ ะฟะพะบะตั
rus_verbs:ะผะพะฑะธะปะธะทะพะฒะฐัั{}, // ะผะพะฑะธะปะธะทะพะฒะฐัั ะฒ ะดะตะนััะฒััััั ะฐัะผะธั
rus_verbs:ะทะฐะปะตัะฐัั{}, // ะทะฐะปะตัะฐัั ะฒ ะทะฐะบัััะพะต ะฒะพะทะดััะฝะพะต ะฟัะพัััะฐะฝััะฒะพ
rus_verbs:ะฟะพะดััะฐัั{}, // ะฟะพะดััะฐัั ะฒ ัััะฑะพัะบั
rus_verbs:ัะผะพัะฐัััั{}, // ัะผะพัะฐัััั ะฒ ะธะฝััะธััั
rus_verbs:ัะฐััะพะฒะฐัั{}, // ัะฐััะพะฒะฐัั ะฒ ะบะฐัะผะฐัะบะธ
rus_verbs:ะทะฐั
ะฐะถะธะฒะฐัั{}, // ะทะฐั
ะฐะถะธะฒะฐัั ะฒ ะดะพะผ
ะธะฝัะธะฝะธัะธะฒ:ัะณะพะฝััั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะณะพะฝััั{ ะฒะธะด:ัะพะฒะตัั }, // ัะณะพะฝััั ะฒ ะปะพะผะฑะฐัะด
ะดะตะตะฟัะธัะฐััะธะต:ัะณะพะฝัั{},
rus_verbs:ะฟะพััะปะฐัััั{}, // ะฟะพััะปะฐัััั ะฒ ะฟะพัั
rus_verbs:ะพัะปะธัั{}, // ะพัะปะธัั ะฒ ะบะฐััััะปั
rus_verbs:ะฟัะตะพะฑัะฐะทะพะฒะฐัััั{}, // ะฟัะตะพะฑัะฐะทะพะฒะฐัััั ะฒ ะปะธะฝะตะนะฝะพะต ััะฐะฒะฝะตะฝะธะต
rus_verbs:ะฟะพะฟะปะฐะบะฐัั{}, // ะฟะพะฟะปะฐะบะฐัั ะฒ ะฟะปะฐัะพัะตะบ
rus_verbs:ะพะฑััััั{}, // ะพะฑััััั ะฒ ัะฐะฟะพะณะธ
rus_verbs:ะทะฐะบะฐะฟะฐัั{}, // ะทะฐะบะฐะฟะฐัั ะฒ ะณะปะฐะทะฐ
ะธะฝัะธะฝะธัะธะฒ:ัะฒะพะทะธัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ัะฒะพะทะธัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะฒะพะทะธัั ะฒ ัะตะฝัั ััะธะปะธะทะฐัะธะธ
ะณะปะฐะณะพะป:ัะฒะพะทะธัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฒะพะทะธัั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ัะฒะพะทะธะฒ{}, ะดะตะตะฟัะธัะฐััะธะต:ัะฒะพะทั{},
rus_verbs:ะฟัะตะพะฑัะฐะทะพะฒะฐัั{}, // ะฟัะตะพะฑัะฐะทะพะฒะฐัั ะฒ ะปะธะฝะตะนะฝะพะต ััะฐะฒะฝะตะฝะธะต
rus_verbs:ะบััะฐัััั{}, // ะบััะฐัััั ะฒ ะฟะปะตะด
rus_verbs:ัะผะตัะฐัััั{}, // ัะผะตัะฐัััั ะฒ ััะพัะพะฝั
rus_verbs:ะทะฐะทัะฒะฐัั{}, // ะทะฐะทัะฒะฐัั ะฒ ัะฒะพะน ะผะฐะณะฐะทะธะฝ
ะธะฝัะธะฝะธัะธะฒ:ััะฐะฝััะพัะผะธัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ััะฐะฝััะพัะผะธัะพะฒะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, // ััะฐะฝััะพัะผะธัะพะฒะฐัััั ะฒ ะบะพะผะฑะธะฝะตะทะพะฝ
ะณะปะฐะณะพะป:ััะฐะฝััะพัะผะธัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ััะฐะฝััะพัะผะธัะพะฒะฐัััั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ััะฐะฝััะพัะผะธััััั{}, ะดะตะตะฟัะธัะฐััะธะต:ััะฐะฝััะพัะผะธัะพะฒะฐะฒัะธัั{},
rus_verbs:ะฟะพะณััะถะฐัั{}, // ะฟะพะณััะถะฐัั ะฒ ะบะธะฟััะตะต ะผะฐัะปะพ
rus_verbs:ะพะฑัะณัะฐัั{}, // ะพะฑัะณัะฐัั ะฒ ัะตะฝะฝะธั
rus_verbs:ะทะฐะบััะฐัั{}, // ะทะฐะบััะฐัั ะฒ ะพะดะตัะปะพ
rus_verbs:ะธะทะปะธะฒะฐัััั{}, // ะธะทะปะธะฒะฐัััั ะฒ ะฒะพะดั
rus_verbs:ะทะฐะบะฐััะฒะฐัั{}, // ะทะฐะบะฐััะฒะฐัั ะฒ ะฐััะฐะปัั
rus_verbs:ะผะพัะฝััััั{}, // ะผะพัะฝััััั ะฒ ะฑะฐะฝะบ
rus_verbs:ะธะทะฑะธัะฐัััั{}, // ะธะทะฑะธัะฐัััั ะฒ ัะตะฝะฐั
rus_verbs:ะฝะฐะฝะธะผะฐัััั{}, // ะฝะฐะฝะธะผะฐัััั ะฒ ััะปัะถะตะฝะธะต
rus_verbs:ะฝะฐััััะฐัั{}, // ะฝะฐััััะฐัั ะฒ ะพัะณะฐะฝั
rus_verbs:ะทะฐะฟะธั
ะธะฒะฐัั{}, // ะทะฐะฟะธั
ะธะฒะฐัั ะฒ ะฟะตัะบั
rus_verbs:ะทะฐะบะฐะฟัะฒะฐัั{}, // ะทะฐะบะฐะฟัะฒะฐัั ะฒ ะฝะพั
rus_verbs:ะทะฐัะพะฑะธัะฐัััั{}, // ะทะฐัะพะฑะธัะฐัััั ะฒ ะฟะพั
ะพะด
rus_verbs:ะบะพะฟะธัะพะฒะฐัั{}, // ะบะพะฟะธัะพะฒะฐัั ะฒ ะดััะณัั ะฟะฐะฟะบั
rus_verbs:ะทะฐะผััะพะฒะฐัั{}, // ะทะฐะผััะพะฒะฐัั ะฒ ััะตะฝั
rus_verbs:ัะฟะตัั{}, // ัะฟะตัั ะฒ ััััะผั
rus_verbs:ะทัะธัั{}, // ะทัะธัั ะฒ ะบะพัะตะฝั
rus_verbs:ัััะณะธะฒะฐัััั{}, // ัััะณะธะฒะฐัััั ะฒ ะพะดะฝั ัะพัะบั
rus_verbs:ััะฐะถะธะฒะฐัั{}, // ััะฐะถะธะฒะฐัั ะฒ ััะตะฝะฐะถะตั
rus_verbs:ะฟัะพัะพะปะบะฝััั{}, // ะฟัะพัะพะปะบะฝััั ะฒ ะพัะฒะตัััะธะต
rus_verbs:ัะฐััะธะฑะธัััั{}, // ัะฐััะธะฑะธัััั ะฒ ะปะตะฟะตัะบั
rus_verbs:ะฟัะธะณะปะฐัะฐัััั{}, // ะฟัะธะณะปะฐัะฐัััั ะฒ ะบะฐะฑะธะฝะตั
rus_verbs:ัะฐะดะธัั{}, // ัะฐะดะธัั ะฒ ัะตะปะตะณั
rus_verbs:ััะบะฝััั{}, // ััะบะฝััั ะฒ ะฟะพะดััะบั
rus_verbs:ะฟัะพัะตัั{}, // ะฟัะพัะตัั ะฒ ะฟะพะดะฒะฐะป
rus_verbs:ะฟะตัะตะณะฝะฐัั{}, // ะฟะตัะตะณะฝะฐัั ะฒ ะดััะณัั ัััะฐะฝั
rus_verbs:ะฟะตัะตะฟะพะปะทัะธ{}, // ะฟะตัะตะฟะพะปะทัะธ ะฒ ัะตะฝั
rus_verbs:ะทะฐััะฒะฐัััั{}, // ะทะฐััะฒะฐัััั ะฒ ะณััะฝั
rus_verbs:ะฟะตัะตะพะดะตัั{}, // ะฟะตัะตะพะดะตัั ะฒ ััั
ัั ะพะดะตะถะดั
rus_verbs:ะฟัะธะฟัััะธัััั{}, // ะฟัะธะฟัััะธัััั ะฒ ะฟะปัั
rus_verbs:ะปะพะฟะพัะฐัั{}, // ะปะพะฟะพัะฐัั ะฒ ะผะธะบัะพัะพะฝ
rus_verbs:ะฟัะพะณะฝััะฐะฒะธัั{}, // ะฟัะพะณะฝััะฐะฒะธัั ะฒ ะผะธะบัะพัะพะฝ
rus_verbs:ะผะพัะธัััั{}, // ะผะพัะธัััั ะฒ ััะฐะฝั
rus_verbs:ะทะฐะณััะถะฐัั{}, // ะทะฐะณััะถะฐัั ะฒ ะฟะฐััะพะฝะฝะธะบ
rus_verbs:ัะฐะดะธัะพะฒะฐัั{}, // ัะฐะดะธัะพะฒะฐัั ะฒ ัะตะฝัั
rus_verbs:ะฟัะพะผะพัะฐัั{}, // ะฟัะพะผะพัะฐัั ะฒ ะบะพะฝะตั
rus_verbs:ะฟะพะผัะฐัั{}, // ะฟะพะผัะฐัั ะฒ ัะบะพะปั
rus_verbs:ััะตะทะถะฐัั{}, // ััะตะทะถะฐัั ะฒ ะบัะฒะตั
rus_verbs:ะทะฐะฒะพะทะธัั{}, // ะทะฐะฒะพะทะธัั ะฒ ะผะฐะณะฐะทะธะฝ
rus_verbs:ะทะฐัะฒะปััััั{}, // ะทะฐัะฒะปััััั ะฒ ัะบะพะปั
rus_verbs:ะฝะฐะณะปัะดะตัััั{}, // ะฝะฐะณะปัะดะตัััั ะฒ ะทะตัะบะฐะปะพ
rus_verbs:ัะฒะพัะฐัะธะฒะฐัััั{}, // ัะฒะพัะฐัะธะฒะฐัััั ะฒ ะบะปัะฑะพัะตะบ
rus_verbs:ััััะตะผะปััั{}, // ััััะตะผะปััั ะฒะทะพั ะฒ ะฑัะดััะตะต
rus_verbs:ะทะฐะฑัะตะดะฐัั{}, // ะทะฐะฑัะตะดะฐัั ะฒ ะณะปัั
ะธะต ัะณะพะปะบะธ
rus_verbs:ะฟะตัะตะผะพัะฐัั{}, // ะฟะตัะตะผะพัะฐัั ะฒ ัะฐะผะพะต ะฝะฐัะฐะปะพ ะดะธะฐะปะพะณะฐ
rus_verbs:ัะผะพัะบะฐัััั{}, // ัะผะพัะบะฐัััั ะฒ ะฝะพัะพะฒะพะน ะฟะปะฐัะพัะตะบ
rus_verbs:ะฟะตัะตัะตะบะฐัั{}, // ะฟะตัะตัะตะบะฐัั ะฒ ะดััะณะพะน ัะพััะด
rus_verbs:ะทะฐะบะฐัะฐัั{}, // ะทะฐะบะฐัะฐัั ะฒ ัะฐัะธะบ
rus_verbs:ะทะฐะฟัััะฐัั{}, // ะทะฐะฟัััะฐัั ะฒ ัะตะนั
rus_verbs:ะฟะธะฝะฐัั{}, // ะฟะธะฝะฐัั ะฒ ะถะธะฒะพั
rus_verbs:ะทะฐัััะฑะธัั{}, // ะทะฐัััะฑะธัั ะฒ ะณะพัะฝ
rus_verbs:ะฟะพะดะณะปัะดัะฒะฐัั{}, // ะฟะพะดะณะปัะดัะฒะฐัั ะฒ ะทะฐะผะพัะฝัั ัะบะฒะฐะถะธะฝั
ะธะฝัะธะฝะธัะธะฒ:ะฟะพะดััะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ะฟะพะดััะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฟะพะดััะฟะฐัั ะฒ ะฟะธััะต
ะณะปะฐะณะพะป:ะฟะพะดััะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฟะพะดััะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะฟะพะดััะฟะฐะฒ{}, ะดะตะตะฟัะธัะฐััะธะต:ะฟะพะดััะฟะฐั{},
rus_verbs:ะทะฐัะพะฒัะฒะฐัั{}, // ะทะฐัะพะฒัะฒะฐัั ะฒ ะฟะตะฝะฐะป
rus_verbs:ะพัััะดะธัั{}, // ะพัััะดะธัั ะฒ ะบะพะผะฐะฝะดะธัะพะฒะบั
rus_verbs:ัะฟัะฐะฒะปััั{}, // ัะฟัะฐะฒะปััั ะฒ ะบัััั
rus_verbs:ะฟะพัะพัะฐะฟะปะธะฒะฐัััั{}, // ะฟะพัะพัะฐะฟะปะธะฒะฐัััั ะฒ ัะฐะผะพะปะตั
rus_verbs:ัะบะพะฟะธัะพะฒะฐัั{}, // ัะบะพะฟะธัะพะฒะฐัั ะฒ ะบัั
rus_verbs:ะฟะพะดะปะธะฒะฐัั{}, // ะฟะพะดะปะธะฒะฐัั ะฒ ะพะณะพะฝั
rus_verbs:ะทะฐะฟัััั{}, // ะทะฐะฟัััั ะฒ ะฟะพะฒะพะทะบั
rus_verbs:ะพะบัะฐัะธัััั{}, // ะพะบัะฐัะธัััั ะฒ ะฟััะฟัั
rus_verbs:ัะบะพะปะพัั{}, // ัะบะพะปะพัั ะฒ ัะตั
rus_verbs:ัะปะตัะตัััั{}, // ัะปะตัะตัััั ะฒ ะณะฝะตะทะดะพ
rus_verbs:ัะตะทะฐัััั{}, // ัะตะทะฐัััั ะฒ ะบะฐััั
rus_verbs:ะทะฐัะตัะฐัััั{}, // ะทะฐัะตัะฐัััั ะฒ ััะดั ะพะฟะฟะพะทะธัะธะพะฝะตัะพะฒ
ะธะฝัะธะฝะธัะธะฒ:ะทะฐะดะฒะธะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะทะฐะดะฒะธะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะทะฐะดะฒะธะณะฐัั ะฒ ััะตะนะบั (ะฝะตัะพะฒะตัั)
ะดะตะตะฟัะธัะฐััะธะต:ะทะฐะดะฒะธะณะฐั{},
rus_verbs:ะดะพััะฐะฒะปััััั{}, // ะดะพััะฐะฒะปััััั ะฒ ัะตััะพัะฐะฝ
rus_verbs:ะฟะพะฟะปะตะฒะฐัั{}, // ะฟะพะฟะปะตะฒะฐัั ะฒ ัะฐัะบั
rus_verbs:ะฟะพะฟะตัะตัััั{}, // ะฟะพะฟะตัะตัััั ะฒ ะผะฐะณะฐะทะธะฝ
rus_verbs:ั
ะฐะถะธะฒะฐัั{}, // ั
ะฐะถะธะฒะฐัั ะฒ ัะตัะบะพะฒั
rus_verbs:ะฟัะตะพะฑัะฐะถะฐัััั{}, // ะฟัะตะพะฑัะฐะถะฐัััั ะฒ ะบะพัะพะปะตะฒั
rus_verbs:ะพัะณะฐะฝะธะทะพะฒะฐัััั{}, // ะพัะณะฐะฝะธะทะพะฒะฐัััั ะฒ ะณััะฟะฟั
rus_verbs:ัะถะฐะปะธัั{}, // ัะถะฐะปะธัั ะฒ ััะบั
rus_verbs:ะฟัะพัะธัะบะธะฒะฐัััั{}, // ะฟัะพัะธัะบะธะฒะฐัััั ะฒ ะฐัะดะธัะพัะธั
rus_verbs:ะฟัะตะฟัะพะฒะพะดะธัั{}, // ะฟัะตะฟัะพะฒะพะดะธัั ะฒ ะทะฐะบััะพะบ
rus_verbs:ัะฐะทัะตะทะถะฐัััั{}, // ัะฐะทัะตะทะถะฐัััั ะฒ ัะฐะทะฝัะต ััะพัะพะฝั
rus_verbs:ะฟัะพะฟัั
ัะตัั{}, // ะฟัะพะฟัั
ัะตัั ะฒ ัััะฑะบั
rus_verbs:ัะฒะพะปะพัั{}, // ัะฒะพะปะพัั ะฒ ะฝะพัั
rus_verbs:ะพัะพะดะฒะธะณะฐัััั{}, // ะพัะพะดะฒะธะณะฐัััั ะฒ ััะพัะพะฝั
rus_verbs:ัะฐะทะปะธะฒะฐัั{}, // ัะฐะทะปะธะฒะฐัั ะฒ ััะฐะบะฐะฝั
rus_verbs:ัะฑะตะณะฐัััั{}, // ัะฑะตะณะฐัััั ะฒ ะฐะบัะพะฒัะน ะทะฐะป
rus_verbs:ะฝะฐะฒะตะดะฐัััั{}, // ะฝะฐะฒะตะดะฐัััั ะฒ ะบะปะฐะดะพะฒะบั
rus_verbs:ะฟะตัะตะบะพัะตะฒะฐัั{}, // ะฟะตัะตะบะพัะตะฒะฐัั ะฒ ะณะพัั
rus_verbs:ะฟัะพัะตะฑะตัะฐัั{}, // ะฟัะพัะตะฑะตัะฐัั ะฒ ัััะฑะบั
rus_verbs:ะฟะตัะตะบะปะฐะดัะฒะฐัั{}, // ะฟะตัะตะบะปะฐะดัะฒะฐัั ะฒ ะดััะณะพะน ะบะฐัะผะฐะฝ
rus_verbs:ัะณะปัะฑะปััััั{}, // ัะณะปัะฑะปััััั ะฒ ัะตะพัะธั
rus_verbs:ะฟะตัะตะธะผะตะฝะพะฒะฐัั{}, // ะฟะตัะตะธะผะตะฝะพะฒะฐัั ะฒ ะณะพัะพะด
rus_verbs:ะฟะตัะตะผะตัะฝััััั{}, // ะฟะตัะตะผะตัะฝััััั ะฒ ะปะฐะณะตัั ะฟัะพัะธะฒะฝะธะบะฐ
rus_verbs:ัะฐะทะฝะพัะธัั{}, // ัะฐะทะฝะพัะธัั ะฒ ัะตะฟะบะธ
rus_verbs:ะพััะฟะฐัััั{}, // ะพััะฟะฐัััั ะฒ ั
ะพะปะพะดะฐ
rus_verbs:ะฟะพะฟัะพัะธัััั{}, // ะฟะพะฟัะพัะธัััั ะฒ ััะฐะปะตั
rus_verbs:ััะทะฒะธัั{}, // ััะทะฒะธัั ะฒ ัะตัะดัะต
rus_verbs:ะฟะตัะตัะฐัะธัั{}, // ะฟะตัะตัะฐัะธัั ะฒ ะดะพะผ
rus_verbs:ะทะฐะบััะฐัััั{}, // ะทะฐะบััะฐัััั ะฒ ะฟะปะตะด
// rus_verbs:ัะฟะฐะบะพะฒะฐัั{}, // ัะฟะฐะบะพะฒะฐัั ะฒ ะฑัะผะฐะณั
ะธะฝัะธะฝะธัะธะฒ:ัะธะบะฐัั{ aux stress="ัะธะบ^ะฐัั" }, ะณะปะฐะณะพะป:ัะธะบะฐัั{ aux stress="ัะธะบ^ะฐัั" }, // ัะธะบะฐัั ะฒ ะบัะตะฟะพััั
rus_verbs:ั
ะธั
ะธะบะฐัั{}, // ั
ะธั
ะธะบะฐัั ะฒ ะบัะปะฐัะพะบ
rus_verbs:ะพะฑัะตะดะธะฝะธัั{}, // ะพะฑัะตะดะธะฝะธัั ะฒ ัะตัั
ะธะฝัะธะฝะธัะธะฒ:ัะปะตัะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะปะตัะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะปะตัะฐัั ะฒ ะะฐะปะธัะพัะฝะธั
ะดะตะตะฟัะธัะฐััะธะต:ัะปะตัะฐะฒ{},
rus_verbs:ะทะฐะฟะพะปะทัะธ{}, // ะทะฐะฟะพะปะทัะธ ะฒ ะฝะพัะบั
rus_verbs:ะฟะตัะตัะฐััะธ{}, // ะฟะตัะตัะฐััะธ ะฒ ะบััะฟะฝัั ะฐัะตัั
rus_verbs:ัะฟะธัะฐัั{}, // ัะฟะธัะฐัั ะฒ ััะธะปั
rus_verbs:ะฟัะพัะฐัะธะฒะฐัััั{}, // ะฟัะพัะฐัะธะฒะฐัััั ะฒ ะฑัะฝะบะตั
rus_verbs:ะฟััะบะฐัััั{}, // ะฟััะบะฐัััั ะฒ ะฟะพะณะพะฝั
rus_verbs:ัะพะณัะตะฒะฐัั{}, // ัะพะณัะตะฒะฐัั ะฒ ะผะพัะพะท
rus_verbs:ะฝะฐะปะธะฒะฐัััั{}, // ะฝะฐะปะธะฒะฐัััั ะฒ ะตะผะบะพััั
rus_verbs:ัะฝะตััะธัั{}, // ัะฝะตััะธัั ะฒ ะฝะตะฑะพ
rus_verbs:ะทะฐัะฒััะฝััั{}, // ะทะฐัะฒััะฝััั ะฒ ัะบะฐั
rus_verbs:ัะธะณะฐะฝััั{}, // ัะธะณะฐะฝััั ะฒ ะฒะพะดั
rus_verbs:ะพะบัะฝััั{}, // ะพะบัะฝััั ะฒ ะปะตะดัะฝัั ะฒะพะดั
rus_verbs:ะฟัะพัะพัะธัััั{}, // ะฟัะพัะพัะธัััั ะฒ ัะฐะฟะพะณ
rus_verbs:ัะพะฒะฐัััั{}, // ัะพะฒะฐัััั ะฒ ัะพะปะฟั
rus_verbs:ะฟัะพัะพะปะบะฐัััั{}, // ะฟัะพัะพะปะบะฐัััั ะฒ ะณะฐัะดะตัะพะฑ
rus_verbs:ะทะฐะปะพะถะธัั{}, // ะทะฐะปะพะถะธัั ะฒ ะปะพะผะฑะฐัะด
rus_verbs:ะฟะตัะตะบะฐัะธัั{}, // ะฟะตัะตะบะฐัะธัั ะฒ ัะฐัะฐะน
rus_verbs:ะฟะพััะฐะฒะปััั{}, // ะฟะพััะฐะฒะปััั ะฒ ะะธัะฐะน
rus_verbs:ะทะฐะปะตะทะฐัั{}, // ะทะฐะปะตะทะฐัั ะฒ ะดะพะปะณะธ
rus_verbs:ะพัะปััะฐัััั{}, // ะพัะปััะฐัััั ะฒ ััะฐะปะตั
rus_verbs:ัะฑะธะฒะฐัััั{}, // ัะฑะธะฒะฐัััั ะฒ ะบััั
rus_verbs:ะทะฐัััั{}, // ะทะฐัััั ะฒ ะทะตะผะปั
rus_verbs:ะทะฐัะฐะดะธัั{}, // ะทะฐัะฐะดะธัั ะฒ ัะตะปะพ
rus_verbs:ะฟัะพัะผัะณะฝััั{}, // ะฟัะพัะผัะณะฝััั ะฒ ะดะฒะตัั
rus_verbs:ะฟะตัะตััะฐะฒะธัั{}, // ะฟะตัะตััะฐะฒะธัั ะฒ ัะบะฐั
rus_verbs:ะพััะฐะปะธัั{}, // ะพััะฐะปะธัั ะฒ ะฟะปะฐะฒะฐะฝะธะต
rus_verbs:ะฝะฐะฑะธัะฐัััั{}, // ะฝะฐะฑะธัะฐัััั ะฒ ะบะพะผะฐะฝะดั
rus_verbs:ะปัะณะฝััั{}, // ะปัะณะฝััั ะฒ ะถะธะฒะพั
rus_verbs:ะฟัะธัะฒะพัะธัั{}, // ะฟัะธัะฒะพัะธัั ะฒ ะถะธะทะฝั
rus_verbs:ะฟัะพะบะพะฒัะปััั{}, // ะฟัะพะบะพะฒัะปััั ะฒ ะณะฐัะดะตัะพะฑ
rus_verbs:ะฟัะธะบะฐัะธัั{}, // ะฟัะธะบะฐัะธัั ะฒ ะณะฐัะฐะถ
rus_verbs:ะทะฐะปะตัะตัั{}, // ะทะฐะปะตัะตัั ะฒ ะพะบะฝะพ
rus_verbs:ะฟะตัะตะดะตะปะฐัั{}, // ะฟะตัะตะดะตะปะฐัั ะฒ ะผะพะฟะตะด
rus_verbs:ะฟัะพัะฐัะธัั{}, // ะฟัะพัะฐัะธัั ะฒ ัะพะฒะตั
rus_verbs:ะพะฑะผะฐะบะฝััั{}, // ะพะฑะผะฐะบะฝััั ะฒ ะฒะพะดั
rus_verbs:ะพัะบะปะพะฝััััั{}, // ะพัะบะปะพะฝััััั ะฒ ััะพัะพะฝั
rus_verbs:ะทะฐะฟะธั
ะฐัั{}, // ะทะฐะฟะธั
ะฐัั ะฒ ะฟะฐะบะตั
rus_verbs:ะธะทะฑะธัะฐัั{}, // ะธะทะฑะธัะฐัั ะฒ ัะพะฒะตั
rus_verbs:ะทะฐะณััะทะธัั{}, // ะทะฐะณััะทะธัั ะฒ ะฑััะตั
rus_verbs:ัะฟะปัะฒะฐัั{}, // ัะฟะปัะฒะฐัั ะฒ ะะฐัะธะถ
rus_verbs:ะทะฐะฑะธะฒะฐัั{}, // ะทะฐะฑะธะฒะฐัั ะฒ ะผะตัะทะปะพัั
rus_verbs:ะฟะพััะบะฐัั{}, // ะฟะพััะบะฐัั ะฒ ะฑะตะทะถะธะทะฝะตะฝะฝัั ัััั
rus_verbs:ััะตะทะถะฐัััั{}, // ััะตะทะถะฐัััั ะฒ ัะฐะฝะฐัะพัะธะน
rus_verbs:ะทะฐะปะตะฟะธัั{}, // ะทะฐะปะตะฟะธัั ะฒ ััะปะพ
rus_verbs:ะฝะฐะฑะธัััั{}, // ะฝะฐะฑะธัััั ะฒ ะบะฐัะผะฐะฝั
rus_verbs:ัะฟะพะปะทัะธ{}, // ัะฟะพะปะทัะธ ะฒ ะฝะพัั
rus_verbs:ัะฟัััะฐัั{}, // ัะฟัััะฐัั ะฒ ะบะฐะผะตัั
rus_verbs:ะฟะตัะตะผะตััะธัั{}, // ะฟะตัะตะผะตััะธัั ะฒ ะบะฐะผะตัั ะฐะฝะฐะฑะธะพะทะฐ
rus_verbs:ะทะฐะบัะฐััััั{}, // ะทะฐะบัะฐััััั ะฒ ะดััั
rus_verbs:ัะผะตััะธัััั{}, // ัะผะตััะธัััั ะฒ ะธะฝััะฐะบัะฐัะฝัั ะพะฑะปะฐััั
rus_verbs:ะทะฐะฟััะบะฐัั{}, // ะทะฐะฟััะบะฐัั ะฒ ัะตัะธั
rus_verbs:ะฟะพััััะธัั{}, // ะฟะพััััะธัั ะฒ ัะฐัะพะฑั
rus_verbs:ะทะฐะฑัะฐััะฒะฐัั{}, // ะทะฐะฑัะฐััะฒะฐัั ะฒ ัะธัััั ะฒะพะดั
rus_verbs:ะฟะตัะตัะตะปะธัั{}, // ะฟะตัะตัะตะปะธัั ะฒ ะพัะดะฐะปะตะฝะฝัั ะดะตัะตะฒะฝั
rus_verbs:ะฟะตัะตะตะทะถะฐัั{}, // ะฟะตัะตะตะทะถะฐัั ะฒ ะฝะพะฒัั ะบะฒะฐััะธัั
rus_verbs:ะฟัะธะฟะพะดะฝะธะผะฐัั{}, // ะฟัะธะฟะพะดะฝะธะผะฐัั ะฒ ะฒะพะทะดัั
rus_verbs:ะดะพะฑะฐะฒะธัััั{}, // ะดะพะฑะฐะฒะธัััั ะฒ ะบะพะฝะตั ะพัะตัะตะดะธ
rus_verbs:ัะฑััั{}, // ัะฑััั ะฒ ัะฐััั
rus_verbs:ะฟะตัะตะดะฒะธะณะฐัั{}, // ะฟะตัะตะดะฒะธะณะฐัั ะฒ ัะพัะตะดะฝัั ะบะปะตัะบั
rus_verbs:ะดะพะฑะฐะฒะปััััั{}, // ะดะพะฑะฐะฒะปััััั ะฒ ะพัะตัะตะดั
rus_verbs:ะดะพะฟะธัะฐัั{}, // ะดะพะฟะธัะฐัั ะฒ ะฟะตัะตัะตะฝั
rus_verbs:ะทะฐะฟะธััะฒะฐัััั{}, // ะทะฐะฟะธััะฒะฐัััั ะฒ ะบััะถะพะบ
rus_verbs:ะฟัะพะดะฐัััั{}, // ะฟัะพะดะฐัััั ะฒ ะบัะตะดะธัะฝะพะต ัะฐะฑััะฒะพ
rus_verbs:ะฟะตัะตะฟะธััะฒะฐัั{}, // ะฟะตัะตะฟะธััะฒะฐัั ะฒ ัะตััะฐะดะบั
rus_verbs:ะทะฐะฟะปััั{}, // ะทะฐะฟะปััั ะฒ ัะตััะธัะพัะธะฐะปัะฝัะต ะฒะพะดั
ะธะฝัะธะฝะธัะธะฒ:ะฟะพะฟะธัะฐัั{ aux stress="ะฟะพะฟ^ะธัะฐัั" }, ะธะฝัะธะฝะธัะธะฒ:ะฟะพะฟะธัะฐัั{ aux stress="ะฟะพะฟะธั^ะฐัั" }, // ะฟะพะฟะธัะฐัั ะฒ ะณะพััะพะบ
ะณะปะฐะณะพะป:ะฟะพะฟะธัะฐัั{ aux stress="ะฟะพะฟ^ะธัะฐัั" }, ะณะปะฐะณะพะป:ะฟะพะฟะธัะฐัั{ aux stress="ะฟะพะฟะธั^ะฐัั" },
rus_verbs:ะพัะฑะธัะฐัั{}, // ะพัะฑะธัะฐัั ะฒ ะณะฒะฐัะดะธั
rus_verbs:ะฝะฐัะตะฟััะฒะฐัั{}, // ะฝะฐัะตะฟััะฒะฐัั ะฒ ะผะธะบัะพัะพะฝ
rus_verbs:ะบะพะฒัะปััั{}, // ะบะพะฒัะปััั ะฒ ััะพะนะปะพ
rus_verbs:ะฟัะธะปะตัะฐัั{}, // ะฟัะธะปะตัะฐัั ะฒ ะะฐัะธะถ
rus_verbs:ะฟัะพะปะธัััั{}, // ะฟัะพะปะธัััั ะฒ ะบะฐะฝะฐะปะธะทะฐัะธั
rus_verbs:ะทะฐะฟะธัะฐัั{}, // ะทะฐะฟะธัะฐัั ะฒ ะผะธะบัะพัะพะฝ
rus_verbs:ะฟะพะดะฒะตะทัะธ{}, // ะฟะพะดะฒะตะทัะธ ะฒ ะฑะพะปัะฝะธัั
rus_verbs:ะฟัะธะฟะตัะตัััั{}, // ะฟัะธะฟะตัะตัััั ะฒ ัะตะฐัั
rus_verbs:ััะตัั{}, // ััะตัั ะฒ ัะตัั
rus_verbs:ะฟัะพััะฒะฐัััั{}, // ะฟัะพััะฒะฐัััั ะฒ ะฑััะตั
rus_verbs:ัะฒะพะทะธัั{}, // ัะฒะพะทะธัั ะฒ ัะตะผะพะฝั
rus_verbs:ััะตะดะฐัั{}, // ััะตะดะฐัั ะฒ ะพะฑะตะด
rus_verbs:ะฟัะพััะฝััััั{}, // ะฟัะพััะฝััััั ะฒ ะดะฒะตัั
rus_verbs:ะฟะตัะตะฝะตััะธัั{}, // ะฟะตัะตะฝะตััะธัั ะฒ ะฟัะพัะปะพะต
rus_verbs:ะทะฐะฒะตะทัะธ{}, // ะทะฐะฒะตะทัะธ ะฒ ะผะฐะณะฐะทะธะฝ
rus_verbs:ะฟัะพะปะพะถะธัั{}, // ะฟัะพะปะพะถะธัั ะฒ ะดะตัะตะฒะฝั
rus_verbs:ะพะฑัะตะดะธะฝััััั{}, // ะพะฑัะตะดะธะฝััััั ะฒ ะฟัะพััะพัะท
rus_verbs:ัะฐะทะฒะธัััั{}, // ัะฐะทะฒะธัััั ะฒ ะฑะฐะฑะพัะบั
rus_verbs:ะทะฐัะตะผะตะฝะธัั{}, // ะทะฐัะตะผะตะฝะธัั ะฒ ะบะฐะฑะธะฝะบั
rus_verbs:ัะบะฐััะฒะฐัััั{}, // ัะบะฐััะฒะฐัััั ะฒ ัะผั
rus_verbs:ะทะฐะฒะพะทะธัััั{}, // ะทะฐะฒะพะทะธัััั ะฒ ะผะฐะณะฐะทะธะฝ
rus_verbs:ะฝะฐะฝะธะผะฐัั{}, // ะฝะฐะฝะธะผะฐัั ะฒ ัะตะนั
rus_verbs:ะฟะพัะฟะตัั{}, // ะฟะพัะฟะตัั ะฒ ะบะปะฐัั
rus_verbs:ะบะธะดะฐัััั{}, // ะบะธะฝะฐัััั ะฒ ะบัะฐะนะฝะพััะธ
rus_verbs:ะฟะพัะฟะตะฒะฐัั{}, // ะฟะพัะฟะตะฒะฐัั ะฒ ะพะฟะตัั
rus_verbs:ะพะฑะตัะฝััั{}, // ะพะฑะตัะฝััั ะฒ ัะพะปัะณั
rus_verbs:ะพะฑัะฐัะธัััั{}, // ะพะฑัะฐัะธัััั ะฒ ะฟัะพะบััะฐัััั
rus_verbs:ะธััะพะปะบะพะฒะฐัั{}, // ะธััะพะปะบะพะฒะฐัั ะฒ ัะฒะพั ะฟะพะปัะทั
rus_verbs:ัะฐัะฐัะธัััั{}, // ัะฐัะฐัะธัััั ะฒ ะดะธัะฟะปะตะน
rus_verbs:ะฟัััะฝััั{}, // ะฟัััะฝััั ะฒ ะบัะปะฐัะพะบ
rus_verbs:ะทะฐะณะฝััั{}, // ะทะฐะณะฝััั ะฒ ะดััะณัั ััะพัะพะฝั
rus_verbs:ัะฐะทะดะฐัั{}, // ัะฐะทะดะฐัั ะฒ ัะฐะทะฝัะต ััะบะธ
rus_verbs:ะฝะฐะทะฝะฐัะธัั{}, // ะฝะฐะทะฝะฐัะธัั ะฒ ะฟัะธะตะผะฝัั ะบะพะผะธััะธั
rus_verbs:ะบะธะดะฐัั{}, // ะบะธะดะฐัั ะฒ ะบัััั
rus_verbs:ัะฒะปะตะบะฐัั{}, // ัะฒะปะตะบะฐัั ะฒ ะปะตั
rus_verbs:ะฟะตัะตัะตะปะธัััั{}, // ะฟะตัะตัะตะปะธัััั ะฒ ััะถะพะต ัะตะปะพ
rus_verbs:ะฟัะธััะปะฐัั{}, // ะฟัะธััะปะฐัั ะฒ ะณะพัะพะด
rus_verbs:ัะฟะปััั{}, // ัะฟะปััั ะฒ ะะฒัะพะฟั
rus_verbs:ะทะฐะฟัะธัะธัะฐัั{}, // ะทะฐะฟัะธัะธัะฐัั ะฒ ะฟะพะปะฝัะน ะณะพะปะพั
rus_verbs:ััะฐัะธัั{}, // ััะฐัะธัั ะฒ ะปะพะณะพะฒะพ
rus_verbs:ะทะฐะฒะตัะฝััััั{}, // ะทะฐะฒะตัะฝััััั ะฒ ะฟะปะตะด
rus_verbs:ะทะฐะฝะพัะธัั{}, // ะทะฐะฝะพัะธัั ะฒ ะฑะปะพะบะฝะพั
rus_verbs:ะฟััะธัััั{}, // ะฟััะธัััั ะฒ ะดะพะผ
rus_verbs:ะฝะฐะฒะตะดัะฒะฐัััั{}, // ะฝะฐะฒะตะดัะฒะฐัััั ะฒ ะฑะพะปัะฝะธัั
rus_verbs:ะฝััััั{}, // ะฝััััั ะฒ ะฟัะพััะฑั
rus_verbs:ะทะฐัะฐััะธัั{}, // ะทะฐัะฐััะธัั ะฒ ะฑะฐั
rus_verbs:ะฝะฐะทะฝะฐัะฐัััั{}, // ะฝะฐะทะฝะฐัะฐะตััั ะฒ ะบะพะผะธััะธั
rus_verbs:ะผะพัะฐัััั{}, // ะผะพัะฐัััั ะฒ ะพะฑะปะฐััะฝะพะน ัะตะฝัั
rus_verbs:ัะฐะทัะณัะฐัั{}, // ัะฐะทัะณัะฐัั ะฒ ะบะฐััั
rus_verbs:ะฟัะพะฟะธัะฐัั{}, // ะฟัะพะฟะธัะฐัั ะฒ ะผะธะบัะพัะพะฝ
rus_verbs:ะฟะธั
ะฝััั{}, // ะฟะธั
ะฝััั ะฒ ะฑะพะบ
rus_verbs:ัะผะธะณัะธัะพะฒะฐัั{}, // ัะผะธะณัะธัะพะฒะฐัั ะฒ ะะฐะฝะฐะดั
rus_verbs:ะฟะพะดะบะปััะธัั{}, // ะฟะพะดะบะปััะธัั ะฒ ัะตัั
rus_verbs:ัะฟะตัะตัั{}, // ัะฟะตัะตัั ะฒ ััะฝะดะฐะผะตะฝั
rus_verbs:ัะฟะปะฐัะธัั{}, // ัะฟะปะฐัะธัั ะฒ ะบะฐััั
rus_verbs:ะฟะพัะฐัะธัััั{}, // ะฟะพัะฐัะธัััั ะฒ ะผะตะดะฟัะฝะบั
rus_verbs:ะฟัะธะณะฝะฐัั{}, // ะฟัะธะณะฝะฐัั ะฒ ััะพะนะปะพ
rus_verbs:ะพััะตัะฝะธัั{}, // ะพััะตัะฝะธัั ะฒ ัะพะนะต
rus_verbs:ััััะฐัััั{}, // ััััะฐัััั ะฒ ะฒะพัะพัะฐ
rus_verbs:ะฟะตัะตัะธัะปะธัั{}, // ะฟะตัะตัะธัะปะธัั ะฒ ัะพะฝะด
rus_verbs:ัะพะผะบะฝััั{}, // ัะพะผะบะฝััั ะฒ ะบััะณ
rus_verbs:ะทะฐะบะฐัะฐัััั{}, // ะทะฐะบะฐัะฐัััั ะฒ ัะตะทะตัะฒัะฐั
rus_verbs:ะบะพะปัะฝััั{}, // ะบะพะปัะฝััั ะฒ ะฑะพะบ
rus_verbs:ะฝะฐะบัะตะฝะธัััั{}, // ะฝะฐะบัะตะฝะธัััั ะฒ ััะพัะพะฝั ะฑะตัะตะณะฐ
rus_verbs:ะฟะพะดะฒะธะฝััััั{}, // ะฟะพะดะฒะธะฝััััั ะฒ ะดััะณัั ััะพัะพะฝั
rus_verbs:ัะฐะทะฝะตััะธ{}, // ัะฐะทะฝะตััะธ ะฒ ะบะปะพััั
rus_verbs:ะพัะปะธะฒะฐัั{}, // ะพัะปะธะฒะฐัั ะฒ ัะพัะผั
rus_verbs:ะฟะพะดะบะธะฝััั{}, // ะฟะพะดะบะธะฝััั ะฒ ะบะฐัะผะฐะฝ
rus_verbs:ัะฒะพะดะธัั{}, // ัะฒะพะดะธัั ะฒ ะบะฐะฑะธะฝะตั
rus_verbs:ััะบะฐะบะฐัั{}, // ััะบะฐะบะฐัั ะฒ ัะบะพะปั
rus_verbs:ัะดะฐัััั{}, // ัะดะฐัััั ะฒ ะฑะฐัะฐะฑะฐะฝั
rus_verbs:ะดะฐัััั{}, // ะดะฐัััั ะฒ ััะบะธ
rus_verbs:ะฟะพัะตะปะพะฒะฐัััั{}, // ะฟะพัะตะปะพะฒะฐัััั ะฒ ะณัะฑั
rus_verbs:ะฟะพัะฒะตัะธัั{}, // ะฟะพัะฒะตัะธัั ะฒ ะฟะพะดะฒะฐะป
rus_verbs:ััะบะฐัั{}, // ััะบะฐัั ะฒ ะฐัะฑัะท
rus_verbs:ัะพะตะดะธะฝััััั{}, // ัะพะตะดะธะฝััััั ะฒ ะบะพะปััะพ
rus_verbs:ัะฐัััะฝััั{}, // ัะฐัััะฝััั ะฒ ัะพะฝะบัั ะฝะธัะพัะบั
rus_verbs:ะฟะพะฑัะพัะฐัั{}, // ะฟะพะฑัะพัะฐัั ะฒ ะฟัะปั
rus_verbs:ัััะบะฝััััั{}, // ัััะบะฝััััั ะฒ ะทะฐะบััััั ะดะฒะตัั
rus_verbs:ะฟัะพะธะณััะฒะฐัั{}, // ะฟัะพะธะณััะฒะฐัั ะฒ ัะตะฝะฝะธั
rus_verbs:ะดัะฝััั{}, // ะดัะฝััั ะฒ ัััะฑะพัะบั
rus_verbs:ัะปะตัะฐัั{}, // ัะปะตัะฐัั ะฒ ะะฐัะธะถ
rus_verbs:ะฟะตัะตะฒะพะดะธัััั{}, // ะฟะตัะตะฒะพะดะธัััั ะฒ ัะธะปะธะฐะป
rus_verbs:ะพะบัะฝััััั{}, // ะพะบัะฝััััั ะฒ ะฒะพะดะพะฒะพัะพั ัะพะฑััะธะน
rus_verbs:ะฟะพะฟัััะฐัััั{}, // ะฟะพะฟัััะฐัััั ะฒ ะฝะพัั
rus_verbs:ะฟะตัะตะฒะตะทัะธ{}, // ะฟะตัะตะฒะตะทัะธ ะฒ ัะพัะตะดะฝัั ะฟะฐะปะฐัั
rus_verbs:ัะพะฟะฐัั{}, // ัะพะฟะฐัั ะฒ ัะบะพะปั
rus_verbs:ะพัะฝะพัะธัั{}, // ะพัะฝะพัะธัั ะฒ ะฟะพะผะตัะตะฝะธะต
rus_verbs:ัะบะปะฐะดัะฒะฐัั{}, // ัะบะปะฐะดัะฒะฐัั ะฒ ััะพะฟะบั
rus_verbs:ัะบะฐัะธัั{}, // ัะบะฐัะธะป ะฒ ัััะฝะต
rus_verbs:ัะฑะธัะฐัั{}, // ัะฑะธัะฐัั ะฒ ััะผะบั
rus_verbs:ะฟะพะผะฐะปะบะธะฒะฐัั{}, // ะฟะพะผะฐะปะบะธะฒะฐัั ะฒ ัััะฟะพัะบั
rus_verbs:ัะพะฝััั{}, // ัะพะฝััั ะฒ ะณััะทั
rus_verbs:ะณะปะฐะทะตัั{}, // ะณะปะฐะทะตัั ะฒ ะฑะธะฝะพะบะปั
rus_verbs:ะฟัะตะพะฑัะฐะทะธัััั{}, // ะฟัะตะพะฑัะฐะทะธัััั ะฒ ะดััะณะพะณะพ ัะตะปะพะฒะตะบะฐ
rus_verbs:ะทะฐะฟััะณะฝััั{}, // ะทะฐะฟััะณะฝััั ะฒ ะฟะพะตะทะด
rus_verbs:ัะณะพะดะธัััั{}, // ัะณะพะดะธัััั ะฒ ััะฟ
rus_verbs:ะฟัะพะฟะพะปะทัะธ{}, // ะฟัะพะฟะพะปะทัะธ ะฒ ะฝะพัั
rus_verbs:ะทะฐะฑะธัะฐัััั{}, // ะทะฐะฑะธัะฐัััั ะฒ ะบะพะปััะบั
rus_verbs:ัะฑะตะถะฐัััั{}, // ัะฑะตะถะฐะปะธัั ะฒ ะบะปะฐัั
rus_verbs:ะทะฐะบะฐัะธัััั{}, // ะทะฐะบะฐัะธัััั ะฒ ัะณะพะป
rus_verbs:ะฟะปะตะฒะฐัั{}, // ะฟะปะตะฒะฐัั ะฒ ะดััั
rus_verbs:ะฟะพะธะณัะฐัั{}, // ะฟะพะธะณัะฐัั ะฒ ะดะตะผะพะบัะฐัะธั
rus_verbs:ะบะฐะฝััั{}, // ะบะฐะฝััั ะฒ ะฝะตะฑััะธะต
rus_verbs:ะพะฟะฐะทะดัะฒะฐัั{}, // ะพะฟะฐะทะดัะฒะฐัั ะฒ ัะบะพะปั
rus_verbs:ะพัะฟะพะปะทัะธ{}, // ะพัะฟะพะปะทัะธ ะฒ ััะพัะพะฝั
rus_verbs:ััะตะบะฐัััั{}, // ััะตะบะฐัััั ะฒ ะพัััะพะนะฝะธะบ
rus_verbs:ะทะฐะฟะธั
ะฝััั{}, // ะทะฐะฟะธั
ะฝััั ะฒ ะฟะฐะบะตั
rus_verbs:ะฒััะฒััะฝััั{}, // ะฒััะฒััะฝััั ะฒ ะบะพัะธะดะพั
rus_verbs:ัะฒัะทัะฒะฐัััั{}, // ัะฒัะทัะฒะฐัััั ะฒ ะฟะปะพัะฝัะน ัะทะตะป
rus_verbs:ะทะฐัะพะปะบะฐัั{}, // ะทะฐัะพะปะบะฐัั ะฒ ัั
ะพ
rus_verbs:ัะบัััะธัั{}, // ัะบัััะธัั ะฒ ัััะฑะพัะบั
rus_verbs:ัะฒะพัะฐัะธะฒะฐัั{}, // ัะฒะพัะฐัะธะฒะฐัั ะฒ ัััะฑะพัะบั
rus_verbs:ัะฟะปะตััะธัั{}, // ัะฟะปะตััะธัั ะฒ ัะทะตะป
rus_verbs:ะทะฐัะบะพัะธัั{}, // ะทะฐัะบะพัะธัั ะฒ ะบะฐะฑะธะฝะตั
rus_verbs:ะฟัะพะฒะฐะปะธะฒะฐัััั{}, // ะฟัะพะฒะฐะปะธะฒะฐัััั ะฒ ัะพะฝ
rus_verbs:ัะฒะตัะพะฒะฐัั{}, // ัะฒะตัะพะฒะฐัั ะฒ ัะฒะพั ะฑะตะทะฝะฐะบะฐะทะฐะฝะฝะพััั
rus_verbs:ะฟะตัะตะฟะธัะฐัั{}, // ะฟะตัะตะฟะธัะฐัั ะฒ ัะตััะฐะดะบั
rus_verbs:ะฟะตัะตะฝะพัะธัััั{}, // ะฟะตัะตะฝะพัะธัััั ะฒ ะผะธั ัะฐะฝัะฐะทะธะน
rus_verbs:ะทะฐะฒะพะดะธัั{}, // ะทะฐะฒะพะดะธัั ะฒ ะฟะพะผะตัะตะฝะธะต
rus_verbs:ััะฝััััั{}, // ััะฝััััั ะฒ ะฐัะดะธัะพัะธั
rus_verbs:ััััะฐะธะฒะฐัััั{}, // ััััะฐะธะฒะฐัััั ะฒ ะฐะฒัะพะผะฐััะตััะบัั
rus_verbs:ะฟัะพะฟััะบะฐัั{}, // ะฟัะพะฟััะบะฐัั ะฒ ะทะฐะป
ะธะฝัะธะฝะธัะธะฒ:ัะฑะตะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ัะฑะตะณะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะฑะตะณะฐัั ะฒ ะบะธะฝะพ
ะณะปะฐะณะพะป:ัะฑะตะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฑะตะณะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ัะฑะตะณะฐั{}, ะดะตะตะฟัะธัะฐััะธะต:ัะฑะตะณะฐะฒ{},
rus_verbs:ะฟัะธะฑะตะณะฐัั{}, // ะฟัะธะฑะตะณะฐัั ะฒ ัะบะพะปั
rus_verbs:ััะตะทะดะธัั{}, // ััะตะทะดะธัั ะฒ ะปะตั
rus_verbs:ะทะฐั
ะปะพะฟะฐัั{}, // ะทะฐั
ะปะพะฟะฐัั ะฒ ะปะฐะดะพัะบะธ
rus_verbs:ะพะฟัะพะบะธะฝััััั{}, // ะพะฟัะพะบะธะฝััััั ะฒ ะณััะทั
ะธะฝัะธะฝะธัะธะฒ:ะฝะฐััะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ะฝะฐััะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ะฝะฐััะฟะฐัั ะฒ ััะฐะบะฐะฝ
ะณะปะฐะณะพะป:ะฝะฐััะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฝะฐััะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะฝะฐััะฟะฐั{}, ะดะตะตะฟัะธัะฐััะธะต:ะฝะฐััะฟะฐะฒ{},
rus_verbs:ัะฟะพััะตะฑะปััั{}, // ัะฟะพััะตะฑะปััั ะฒ ะฟะธัั
rus_verbs:ะฟัะธะฒะพะดะธัััั{}, // ะฟัะธะฒะพะดะธัััั ะฒ ะดะตะนััะฒะธะต
rus_verbs:ะฟัะธัััะพะธัั{}, // ะฟัะธัััะพะธัั ะฒ ะฝะฐะดะตะถะฝัะต ััะบะธ
rus_verbs:ััะบะฝััั{}, // ััะบะฝััั ะฒ ะฝะพัั
rus_verbs:ะพะฑัะตะดะธะฝะธัััั{}, // ะพะฑัะตะดะธะฝะธัััั ะฒ ะฑะฐะฝะดั
rus_verbs:ัะฐะถะฐัั{}, // ัะฐะถะฐัั ะฒ ะพะดะธะฝะพัะบั
rus_verbs:ัะพะตะดะธะฝะธัั{}, // ัะพะตะดะธะฝะธัั ะฒ ะบะพะปััะพ
rus_verbs:ะทะฐะฑัะตััะธ{}, // ะทะฐะฑัะตััะธ ะฒ ะบะฐัะตัะบั
rus_verbs:ัะฒะตัะฝััััั{}, // ัะฒะตัะฝััััั ะฒ ะบะปัะฑะพัะตะบ
rus_verbs:ะฟะตัะตัะตััั{}, // ะฟะตัะตัะตััั ะฒ ะดััะณะพะน ะฐะฒัะพะฑัั
rus_verbs:ะฟะพััััะฐัััั{}, // ะฟะพััััะฐัััั ะฒ ะดะฒะตััั
rus_verbs:ัะพะตะดะธะฝััั{}, // ัะพะตะดะธะฝััั ะฒ ะบะพะปััะพ
rus_verbs:ะฟัะธะฒะพะปะพัั{}, // ะฟัะธะฒะพะปะพัั ะฒ ะบะพะผะพัะบั
rus_verbs:ัะผะฐั
ะธะฒะฐัั{}, // ัะผะฐั
ะธะฒะฐัั ะฒ ััะธะบ ััะพะปะฐ
rus_verbs:ะทะฐะฑะตะถะฐัั{}, // ะทะฐะฑะตะถะฐัั ะฒ ะฟะพะผะตัะตะฝะธะต
rus_verbs:ัะตะปะธัััั{}, // ัะตะปะธัััั ะฒ ะฑะตะณะปะตัะฐ
rus_verbs:ะฟัะพะบัะฐััััั{}, // ะฟัะพะบัะฐััััั ะฒ ั
ัะฐะฝะธะปะธัะต
rus_verbs:ะทะฐะบะพะฒัะปััั{}, // ะทะฐะบะพะฒัะปััั ะฒ ััะฐะฒัะฐะผะพะปะพะณะธั
rus_verbs:ะฟัะธัะบะฐะบะฐัั{}, // ะฟัะธัะบะฐะบะฐัั ะฒ ััะพะนะปะพ
rus_verbs:ะบะพะปะพัะธัั{}, // ะบะพะปะพัะธัั ะฒ ะดะฒะตัั
rus_verbs:ัะผะพััะตัััั{}, // ัะผะพััะตัััั ะฒ ะทะตัะบะฐะปะพ
rus_verbs:ะฟะพะดะปะพะถะธัั{}, // ะฟะพะดะปะพะถะธัั ะฒ ัะฐะปะพะฝ
rus_verbs:ะฟััะฐัั{}, // ะฟััะฐัั ะฒ ะบะพัะพะปะตะฒัะบะธะต ะฟะพะบะพะธ
rus_verbs:ัะพะณะฝััั{}, // ัะพะณะฝััั ะฒ ะดัะณั
rus_verbs:ะทะฐะฑะฐัะฐะฑะฐะฝะธัั{}, // ะทะฐะฑะฐัะฐะฑะฐะฝะธัั ะฒ ะดะฒะตัั
rus_verbs:ะพัะบะปะพะฝะธัั{}, // ะพัะบะปะพะฝะธัั ะฒ ััะพัะพะฝั ะฟะพัะฐะดะพัะฝะพะน ะฟะพะปะพัั
rus_verbs:ัะฑัะฐัััั{}, // ัะฑัะฐัััั ะฒ ัะฟะตัะธะฐะปัะฝัั ะฝะธัั
rus_verbs:ะฝะฐัะผะพััะตัััั{}, // ะฝะฐัะผะพััะตัััั ะฒ ะทะตัะบะฐะปะพ
rus_verbs:ัะผะพะบะฝััั{}, // ัะผะพะบะฝััั ะฒ ัะตัะบั
rus_verbs:ััะผะตั
ะฐัััั{}, // ััะผะตั
ะฐัััั ะฒ ะฑะพัะพะดั
rus_verbs:ะฟะตัะตะดะฒะธะฝััั{}, // ะฟะตัะตะดะฒะธะฝััั ะฒ ะบะพะฝะตั ะพัะตัะตะดะธ
rus_verbs:ะดะพะฟััะบะฐัััั{}, // ะดะพะฟััะบะฐัััั ะฒ ะพะฟะพัะธะฒะฐะปัะฝั
rus_verbs:ะทะฐะดะฒะธะฝััั{}, // ะทะฐะดะฒะธะฝััั ะฒ ะดะฐะปัะฝะธะน ัะณะพะป
rus_verbs:ะพัะฟัะฐะฒะปััั{}, // ะพัะฟัะฐะฒะปััั ะฒ ัะตะฝัั
rus_verbs:ัะฑัะฐััะฒะฐัั{}, // ัะฑัะฐััะฒะฐัั ะฒ ะถะตัะปะพ
rus_verbs:ัะฐััััะตะปะธะฒะฐัั{}, // ัะฐััััะตะปะธะฒะฐัั ะฒ ะผะพะผะตะฝั ะพะฑะฝะฐััะถะตะฝะธั
rus_verbs:ะทะฐะฒะพะปะพัั{}, // ะทะฐะฒะพะปะพัั ะฒ ะทะฐะบััะพะบ
rus_verbs:ะฟัะพะปะธัั{}, // ะฟัะพะปะธัั ะฒ ะฒะพะดั
rus_verbs:ะทะฐัััััั{}, // ะทะฐัััััั ะฒ ัะตะฝะพ
rus_verbs:ะฟะตัะตะปะธะฒะฐัััั{}, // ะฟะตัะตะปะธะฒะฐัััั ะฒ ะตะผะบะพััั
rus_verbs:ะทะฐัะฐัะธัั{}, // ะทะฐัะฐัะธัั ะฒ ะบะปัะฑ
rus_verbs:ะฟะตัะตะฑะตะถะฐัั{}, // ะฟะตัะตะฑะตะถะฐัั ะฒ ะปะฐะณะตัั ะฒัะฐะณะพะฒ
rus_verbs:ะพะดะตัั{}, // ะพะดะตัั ะฒ ะฝะพะฒะพะต ะฟะปะฐััะต
ะธะฝัะธะฝะธัะธะฒ:ะทะฐะดะฒะธะณะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะทะฐะดะฒะธะณะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะทะฐะดะฒะธะณะฐัััั ะฒ ะฝะธัั
ะดะตะตะฟัะธัะฐััะธะต:ะทะฐะดะฒะธะณะฐััั{},
rus_verbs:ะบะปัะฝััั{}, // ะบะปัะฝััั ะฒ ัะตะผะตัะบะพ
rus_verbs:ะฝะฐะปะธะฒะฐัั{}, // ะฝะฐะปะธะฒะฐัั ะฒ ะบััะถะบั
rus_verbs:ะฟัะพะปะตะทัั{}, // ะฟัะพะปะตะทัั ะฒ ััะบะพ
rus_verbs:ะพัะบะปะฐะดัะฒะฐัั{}, // ะพัะบะปะฐะดัะฒะฐัั ะฒ ััะธะบ
rus_verbs:ะฟัะพััะฝััััั{}, // ะฟัะพััะฝััััั ะฒ ัะพัะตะดะฝะธะน ะดะพะผ
rus_verbs:ัะปะตะฟะฝััััั{}, // ัะปะตะฟะฝััััั ะปะธัะพะผ ะฒ ะณััะทั
rus_verbs:ัััะฐะฝะฐะฒะปะธะฒะฐัั{}, // ัััะฐะฝะฐะฒะปะธะฒะฐัั ะฒ ะผะฐัะธะฝั
rus_verbs:ัะฟะพััะตะฑะปััััั{}, // ัะฟะพััะตะฑะปััััั ะฒ ะฟะธัั
rus_verbs:ะฟะตัะตะบะปััะธัััั{}, // ะฟะตัะตะบะปััะธัััั ะฒ ัะตะฒะตััะฝัะน ัะตะถะธะผ
rus_verbs:ะฟะธัะบะฝััั{}, // ะฟะธัะบะฝััั ะฒ ะผะธะบัะพัะพะฝ
rus_verbs:ะทะฐัะฒะธัััั{}, // ะทะฐัะฒะธัััั ะฒ ะบะปะฐัั
rus_verbs:ะฝะฐะปะธัััั{}, // ะฝะฐะปะธัััั ะฒ ััะฐะบะฐะฝ
rus_verbs:ะทะฐะปะธะฒะฐัั{}, // ะทะฐะปะธะฒะฐัั ะฒ ะฑะฐะบ
rus_verbs:ััะฐะฒะธัััั{}, // ััะฐะฒะธัััั ะฒ ะพัะตัะตะดั
ะธะฝัะธะฝะธัะธะฒ:ะฟะธัะฐัััั{ aux stress="ะฟ^ะธัะฐัััั" }, ะณะปะฐะณะพะป:ะฟะธัะฐัััั{ aux stress="ะฟ^ะธัะฐัััั" }, // ะฟะธัะฐัััั ะฒ ััะฐะฝั
ะดะตะตะฟัะธัะฐััะธะต:ะฟะธัะฐััั{},
rus_verbs:ัะตะปะพะฒะฐัััั{}, // ัะตะปะพะฒะฐัััั ะฒ ะณัะฑั
rus_verbs:ะฝะฐะฝะพัะธัั{}, // ะฝะฐะฝะพัะธัั ะฒ ะพะฑะปะฐััั ัะตัะดัะฐ
rus_verbs:ะฟะพัะผะตััััั{}, // ะฟะพัะผะตััััั ะฒ ะบัะปะฐัะพะบ
rus_verbs:ัะฟะพััะตะฑะธัั{}, // ัะฟะพััะตะฑะธัั ะฒ ะฟะธัั
rus_verbs:ะฟัะพัะฒะฐัััั{}, // ะฟัะพัะฒะฐัััั ะฒ ััะพะปะพะฒัั
rus_verbs:ัะบะปะฐะดัะฒะฐัััั{}, // ัะบะปะฐะดัะฒะฐัััั ะฒ ัะพะฒะฝัะต ััะพะฟะบะธ
rus_verbs:ะฟัะพะฑะธัััั{}, // ะฟัะพะฑะธัััั ะฒ ัะธะฝะฐะป
rus_verbs:ะทะฐะฑะธัั{}, // ะทะฐะฑะธัั ะฒ ะทะตะผะปั
rus_verbs:ะฟะตัะตะปะพะถะธัั{}, // ะฟะตัะตะปะพะถะธัั ะฒ ะดััะณะพะน ะบะฐัะผะฐะฝ
rus_verbs:ะพะฟััะบะฐัั{}, // ะพะฟััะบะฐัั ะฒ ัะฒะตะถะตะฒัััััั ะผะพะณะธะปั
rus_verbs:ะฟะพัะพัะพะฟะธัััั{}, // ะฟะพัะพัะพะฟะธัััั ะฒ ัะบะพะปั
rus_verbs:ัะดะฒะธะฝััััั{}, // ัะดะฒะธะฝััััั ะฒ ััะพัะพะฝั
rus_verbs:ะบะฐะฟะฐัั{}, // ะบะฐะฟะฐัั ะฒ ัะผะตัั
rus_verbs:ะฟะพะณััะถะฐัััั{}, // ะฟะพะณััะถะฐัััั ะฒะพ ััะผั
rus_verbs:ะฝะฐะฟัะฐะฒะปััั{}, // ะฝะฐะฟัะฐะฒะปััั ะฒ ะบะฐะฑะธะฝะบั
rus_verbs:ะฟะพะณััะทะธัั{}, // ะฟะพะณััะทะธัั ะฒะพ ััะผั
rus_verbs:ะฟัะธะผัะฐัััั{}, // ะฟัะธะผัะฐัััั ะฒ ัะบะพะปั
rus_verbs:ัะฟะธัะฐัััั{}, // ัะฟะธัะฐัััั ะฒ ะดะฒะตัั
rus_verbs:ัะดะฐะปััััั{}, // ัะดะฐะปััััั ะฒ ะบะพะผะฝะฐัั ัะพะฒะตัะฐะฝะธะน
rus_verbs:ัะบะฝััััั{}, // ัะบะฝััััั ะฒ ะพะบะพัะบะพ
rus_verbs:ัะฑะตะณะฐัั{}, // ัะฑะตะณะฐัั ะฒ ัะฐัั
rus_verbs:ัะพะตะดะธะฝะธัััั{}, // ัะพะตะดะธะฝะธัััั ะฒ ะฝะตะพะฑััะฝัั ะฟัะพัััะฐะฝััะฒะตะฝะฝัั ัะธะณััั
rus_verbs:ะฝะฐะณะพะฒะพัะธัั{}, // ะฝะฐะณะพะฒะพัะธัั ะฒ ะผะธะบัะพัะพะฝ
rus_verbs:ะฟะตัะตะฝะพัะธัั{}, // ะฟะตัะตะฝะพัะธัั ะฒ ะดะพะผ
rus_verbs:ะฟัะธะปะตัั{}, // ะฟัะธะปะตัั ะฒ ะบัะพะฒะฐัะบั
rus_verbs:ะฟะพะฒะพัะฐัะธะฒะฐัั{}, // ะฟะพะฒะพัะฐัะธะฒะฐัั ะฒ ะพะฑัะฐัะฝัั ััะพัะพะฝั
rus_verbs:ะฟัะพัะบะพัะธัั{}, // ะฟัะพัะบะพัะธัั ะฒ ัะตะปั
rus_verbs:ัะพะฒะฐัั{}, // ัะพะฒะฐัั ะฒ ะดัั
ะพะฒะบั
rus_verbs:ะฟะตัะตะพะดะตัััั{}, // ะฟะตัะตะพะดะตัััั ะฒ ัะธัััั ะพะดะตะถะดั
rus_verbs:ะฟะพัะฒะฐัั{}, // ะฟะพัะฒะฐัั ะฒ ะปะพัะบััั
rus_verbs:ะทะฐะฒัะทะฐัั{}, // ะทะฐะฒัะทะฐัั ะฒ ะฑะฐัะฐะฝะธะน ัะพะณ
rus_verbs:ััะตั
ะฐัั{}, // ััะตั
ะฐัั ะฒ ะบัะฒะตั
rus_verbs:ะปะธัััั{}, // ะปะธัััั ะฒ ะบะฐะฝะธัััั
rus_verbs:ัะบะปะพะฝะธัััั{}, // ัะบะปะพะฝะธัััั ะฒ ะปะตะฒัั ััะพัะพะฝั
rus_verbs:ัะผะฐั
ะฝััั{}, // ัะผะฐั
ะฝััั ะฒ ะผััะพัะฝะพะต ะฒะตะดัะพ
rus_verbs:ัะฟััะบะฐัั{}, // ัะฟััะบะฐัั ะฒ ัะฐั
ัั
rus_verbs:ะฟะปะตัะฝััั{}, // ะฟะปะตัะฝััั ะฒ ะฒะพะดั
rus_verbs:ะฟะพะดััั{}, // ะฟะพะดััั ะฒ ัะณะพะปัะบะธ
rus_verbs:ะฝะฐะฑะธัะฐัั{}, // ะฝะฐะฑะธัะฐัั ะฒ ะบะพะผะฐะฝะดั
rus_verbs:ั
ะปะพะฟะฐัั{}, // ั
ะปะพะฟะฐัั ะฒ ะปะฐะดะพัะบะธ
rus_verbs:ัะฐะฝะธัั{}, // ัะฐะฝะธัั ะฒ ัะฐะผะพะต ัะตัะดัะต
rus_verbs:ะฟะพัะผะฐััะธะฒะฐัั{}, // ะฟะพัะผะฐััะธะฒะฐัั ะฒ ะธะปะปัะผะธะฝะฐัะพั
rus_verbs:ะฟัะตะฒัะฐัะฐัั{}, // ะฟัะตะฒัะฐัะฐัั ะฒะพะดั ะฒ ะฒะธะฝะพ
rus_verbs:ัะพะปะบะฐัั{}, // ัะพะปะบะฐัั ะฒ ะฟััะธะฝั
rus_verbs:ะพัะฑััั{}, // ะพัะฑััั ะฒ ัะฐัะฟะพะปะพะถะตะฝะธะต ัะฐััะธ
rus_verbs:ัะณัะตััะธ{}, // ัะณัะตััะธ ะฒ ะบะฐัะผะฐะฝ
rus_verbs:ัะดัะฐัั{}, // ัะดัะฐัั ะฒ ัะฐะนะณั
rus_verbs:ะฟัะธัััะพะธัััั{}, // ะฟัะธัััะพะธัััั ะฒ ั
ะพัะพััั ัะธัะผั
rus_verbs:ัะฑะธัััั{}, // ัะฑะธัััั ะฒ ะฟะปะพัะฝัั ะณััะฟะฟั
rus_verbs:ะทะฐะบะปััะฐัั{}, // ะทะฐะบะปััะฐัั ะฒ ะพะฑัััะธั
rus_verbs:ะพัะฟััะบะฐัั{}, // ะพัะฟััะบะฐัั ะฒ ะฟะพั
ะพะด
rus_verbs:ััััะตะผะธัั{}, // ััััะตะผะธัั ะฒะทะณะปัะด ะฒ ะฑัะดััะตะต
rus_verbs:ะพะฑัะพะฝะธัั{}, // ะพะฑัะพะฝะธัั ะฒ ััะฐะฒั
rus_verbs:ัะปะธะฒะฐัััั{}, // ัะปะธะฒะฐัััั ะฒ ัะตัะบั
rus_verbs:ััะตะบะฐัั{}, // ััะตะบะฐัั ะฒ ะบะฐะฝะฐะฒั
rus_verbs:ัะฒะฐะปะธัั{}, // ัะฒะฐะปะธัั ะฒ ะบััั
rus_verbs:ะฟะพะดััะฝััั{}, // ะฟะพะดััะฝััั ะฒ ะบะฐะฑะธะฝั
rus_verbs:ัะบะฐัะธัััั{}, // ัะบะฐัะธัััั ะฒ ะบะฐะฝะฐะฒั
rus_verbs:ะฟัะพัะบะพะปัะทะฝััั{}, // ะฟัะพัะบะพะปัะทะฝััั ะฒ ะฟัะธะพัะบััััั ะดะฒะตัั
rus_verbs:ะทะฐัะพัะพะฟะธัััั{}, // ะทะฐัะพัะพะฟะธัััั ะฒ ะฑััะตั
rus_verbs:ะฟัะพัะธัะฝััััั{}, // ะฟัะพัะธัะฝััััั ะฒ ัะตะฝัั ัะพะปะฟั
rus_verbs:ะฟัััะฐัั{}, // ะฟัััะฐัั ะฒ ัะบัะพะผะฝะตะฝัะบะพะต ะผะตััะตัะบะพ
rus_verbs:ะฟัะพะฟะตัั{}, // ะฟัะพะฟะตัั ะฒ ะผะธะบัะพัะพะฝ
rus_verbs:ัะณะปัะฑะธัััั{}, // ัะณะปัะฑะธัััั ะฒ ะดะถัะฝะณะปะธ
rus_verbs:ัะฟะพะปะทัะธ{}, // ัะฟะพะปะทัะธ ะฒ ัะผั
rus_verbs:ะทะฐะฟะธััะฒะฐัั{}, // ะทะฐะฟะธััะฒะฐัั ะฒ ะฟะฐะผััั
rus_verbs:ัะฐััััะตะปััั{}, // ัะฐััััะตะปััั ะฒ ัะฟะพั (ะฝะฐัะตัะฝัะน ะพะฑะพัะพั ะ ะฃะะะ )
rus_verbs:ะบะพะปะพัะธัััั{}, // ะบะพะปะพัะธัััั ะฒ ะดะฒะตัั
rus_verbs:ะฟัะพััะฝััั{}, // ะฟัะพััะฝััั ะฒ ะพัะฒะตัััะธะต
rus_verbs:ะฟัะพะฒะพะถะฐัั{}, // ะฟัะพะฒะพะถะฐัั ะฒ ะฐัะผะธั
rus_verbs:ะบะฐัะธัั{}, // ะบะฐัะธัั ะฒ ะณะฐัะฐะถ
rus_verbs:ะฟะพัะฐะถะฐัั{}, // ะฟะพัะฐะถะฐัั ะฒ ัะฐะผะพะต ัะตัะดัะต
rus_verbs:ะพัะปะตัะตัั{}, // ะพัะปะตัะตัั ะฒ ะดะฐะปัะฝะธะน ัะณะพะป
rus_verbs:ะทะฐะบะธะฝััั{}, // ะทะฐะบะธะฝััั ะฒ ัะตัะบั
rus_verbs:ะบะฐัะธัััั{}, // ะบะฐัะธัััั ะฒ ะฟัะพะฟะฐััั
rus_verbs:ะทะฐะฑัะพัะธัั{}, // ะทะฐะฑัะพัะธัั ะฒ ะดะฐะปัะฝะธะน ัะณะพะป
rus_verbs:ะพัะฒะตะทัะธ{}, // ะพัะฒะตะทัะธ ะฒ ะปะฐะณะตัั
rus_verbs:ะฒัะพะฟะธัั{}, // ะฒัะพะฟะธัั ะฟะตะดะฐะปั ะฒ ะฟะพะป
rus_verbs:ะฒัะฐะฟะปะธะฒะฐัั{}, // ะฒัะฐะฟะปะธะฒะฐัั ะฟะตะดะฐัั ะฒ ะฟะพะป
rus_verbs:ััะพะฟะธัั{}, // ััะพะฟะธัั ะบะฝะพะฟะบั ะฒ ะฟะฐะฝะตะปั
rus_verbs:ะฝะฐะฟะฐััั{}, // ะ ะะตะบะธะฝะต ััะฐััะฝะธะบะธ ะฐะฝัะธัะฟะพะฝัะบะธั
ะฟัะพัะตััะพะฒ ะฝะฐะฟะฐะปะธ ะฝะฐ ะผะฐัะธะฝั ะฟะพัะปะฐ ะกะจะ
rus_verbs:ะฝะฐะฝััั{}, // ะะพัั ะฝะฐะฝัะป ะฒ ัะปัะถะฑั ะฟะพะดะดะตัะถะบะธ ะตัะต ะฝะตัะบะพะปัะบะพ ะดะตะฒััะตะบ
rus_verbs:ะฟะตัะตะฒะพะดะธัั{}, // ะฟะตัะตะฒะพะดะธัั ะฒ ัััะพะนัะธะฒัั ะบ ะฟะตัะตะณัะตะฒั ัะพัะผั
rus_verbs:ะฑะฐะปะปะพัะธัะพะฒะฐัั{}, // ะฟัะตัะตะฝะดะตะฝั ะฑัะป ะฑะฐะปะปะพัะธัะพะฒะฐะฝ ะฒ ะถััะธ (ะฑะฐะปะปะพัะธัะพะฒะฐะฝ?)
rus_verbs:ะฒะฑัั
ะฐัั{}, // ะะปะฐััะธ ะฒะฑัั
ะฐะปะธ ะฒ ััะพะน ะฟัะพะตะบั ะผะฝะพะณะพ ะดะตะฝะตะณ
rus_verbs:ะฒะฑัั
ะธะฒะฐัั{}, // ะะปะฐััะธ ะฒะฑัั
ะธะฒะฐัั ะฒ ััะพั ะฟัะพะตะบั ะพัะตะฝั ะผะฝะพะณะพ ะดะตะฝะตะณ
rus_verbs:ะฟะพัะบะฐะบะฐัั{}, // ะฟะพัะบะฐะบะฐัั ะฒ ะฐัะฐะบั
rus_verbs:ะฟัะธัะตะปะธัััั{}, // ะฟัะธัะตะปะธัััั ะฒ ะฑะตะณััะตะณะพ ะทะฐะนัะฐ
rus_verbs:ะฟััะณะฐัั{}, // ะฟััะณะฐัั ะฒ ะบัะพะฒะฐัั
rus_verbs:ะฟัะธะณะปะฐัะฐัั{}, // ะฟัะธะณะปะฐัะฐัั ะฒ ะดะพะผ
rus_verbs:ะฟะพะฝะตััะธัั{}, // ะฟะพะฝะตััะธัั ะฒ ะฒะพัะพัะฐ
rus_verbs:ะทะฐะตั
ะฐัั{}, // ะทะฐะตั
ะฐัั ะฒ ะณะฐัะฐะถะฝัะน ะฑะพะบั
rus_verbs:ะพะฟััะบะฐัััั{}, // ะพะฟััะบะฐัััั ะฒ ะฑะตะทะดะฝั
rus_verbs:ะฟะตัะตะตั
ะฐัั{}, // ะฟะตัะตะตั
ะฐัั ะฒ ะบะพััะตะดะถ
rus_verbs:ะฟะพะผะตััะธัั{}, // ะฟะพะผะตััะธัั ะฒ ะบะฐัะฐะฝัะธะฝ
rus_verbs:ะฟะพะปะทัะธ{}, // ะฟะพะปะทัะธ ะฒ ะฝะพัั
rus_verbs:ะดะพะฑะฐะฒะปััั{}, // ะดะพะฑะฐะฒะปััั ะฒ ะบะพัะทะธะฝั
rus_verbs:ััะบะฝััััั{}, // ััะบะฝััััั ะฒ ะฟะพะดััะบั
rus_verbs:ะฟัะพะดะฐะฒะฐัั{}, // ะฟัะพะดะฐะฒะฐัั ะฒ ัะฐะฑััะฒะพ
rus_verbs:ัะฟัััะฐัััั{}, // ะะตะปะบะฐ ัะฟัััะตััั ะฒ ะดัะฟะปะพ.
rus_verbs:ะฒัะธัะพะฒัะฒะฐัั{}, // ะฒัะธัะพะฒัะฒะฐัั ะฝะพะฒัะน ะฟะตััะพะฝะฐะถ ะฒ ะฐะฝะธะผะฐัะธั
rus_verbs:ะฒะพัะบะฝััั{}, // ะฒะพัะบะฝะธ ะฒะธะปะบั ะฒ ัะพะทะตัะบั
rus_verbs:ะฝะตััะธ{}, // ะฝะตััะธ ะฒ ะฑะพะปัะฝะธัั
rus_verbs:ะฒะพัะบะฝััััั{}, // ะฒะธะปะบะฐ ะฒะพัะบะฝัะปะฐัั ะฒ ัะพัะฝัั ะบะพัะปะตัะบั
rus_verbs:ะฒะฟะฐะธะฒะฐัั{}, // ะฒะฟะฐะธะฒะฐัั ะดะตัะฐะปั ะฒ ะฟะปะฐัั
rus_verbs:ะฒะฟะฐะธะฒะฐัััั{}, // ะดะตัะฐะปั ะฒะฟะฐะธะฒะฐะตััั ะฒ ะฟะปะฐัั
rus_verbs:ะฒะฟะฐัั
ะธะฒะฐัั{}, // ะฒะฟะฐัั
ะธะฒะฐัั ะฒ ะฟะพะผะตัะตะฝะธะต
rus_verbs:ะฒะฟะฐััั{}, // ะฒะฟะฐััั ะดะตัะฐะปั ะฒ ะฟะปะฐัั
rus_verbs:ะฒะฟะตะฝะดััะธะฒะฐัั{}, // ะฒะฟะตะฝะดััะธะฒะฐัั ัััะบะตะฝัะธั ะฒ ะฐะณัะตะณะฐั
rus_verbs:ะฒะฟะตะฝะดััะธัั{}, // ะฒะฟะตะฝะดััะธัั ัััะบะตะฝัะธั ะฒ ะฐะณัะตะณะฐั
rus_verbs:ะฒะฟะตัะธะฒะฐัั{}, // ะฒะฟะตัะธะฒะฐัั ะฒะทะณะปัะด ะฒ ัะบัะฐะฝ
rus_verbs:ะฒะฟะตัะธะฒะฐัััั{}, // ะฒะฟะตัะธะฒะฐัััั ะฒ ัะบัะฐะฝ
rus_verbs:ะฒะฟะตัะธัั{}, // ะฒะฟะตัะธัั ะฒะทะณะปัะด ะฒ ัะบัะฐะฝ
rus_verbs:ะฒะฟะตัะธัััั{}, // ะฒะฟะตัะธัััั ะฒ ัะบัะฐะฝ
rus_verbs:ะฒะฟะตัััั{}, // ะฒะฟะตัััั ะฒะทะณะปัะด ะฒ ัะบัะฐะฝ
rus_verbs:ะฒะฟะตัััััั{}, // ะฒะฟะตัััััั ะฒ ัะบัะฐะฝ
rus_verbs:ะฒะฟะตัะฐัะฐัั{}, // ะฒะฟะตัะฐัะฐัั ัะตะบัั ะฒ ะฟะตัะฒัั ะณะปะฐะฒั
rus_verbs:ะฒะฟะตัะฐัะฐัััั{}, // ะฒะฟะตัะฐัะฐัััั ะฒ ััะตะฝั
rus_verbs:ะฒะฟะตัะฐััะฒะฐัั{}, // ะฒะฟะตัะฐััะฒะฐัั ัะตะบัั ะฒ ะฟะตัะฒัั ะณะปะฐะฒั
rus_verbs:ะฒะฟะตัะฐััะฒะฐัััั{}, // ะฒะฟะตัะฐััะฒะฐัััั ะฒ ััะตะฝั
rus_verbs:ะฒะฟะธะฒะฐัััั{}, // ะฅะธัะฝะธะบ ะฒะฟะธะฒะฐะตััั ะฒ ะถะตััะฒั ะผะพัะฝัะผะธ ะทัะฑะฐะผะธ
rus_verbs:ะฒะฟะธัะฐัััั{}, // ะะธะดะบะพััั ะฒะฟะธัะฐะปะฐัั ะฒ ัะบะฐะฝั
rus_verbs:ะฒะฟะธััะฒะฐัััั{}, // ะะธะดะบะพััั ะฒะฟะธััะฒะฐะตััั ะฒ ัะบะฐะฝั
rus_verbs:ะฒะฟะธั
ะธะฒะฐัั{}, // ะะฐะผะฐ ะฒะฟะธั
ะธะฒะฐะตั ะฒ ััะผะบั ะบััะพะบ ะบะพะปะฑะฐัั
rus_verbs:ะฒะฟะธั
ะธะฒะฐัััั{}, // ะััะพะบ ะบะพะปะฑะฐัั ะฒะฟะธั
ะธะฒะฐะตััั ะฒ ััะผะบั
rus_verbs:ะฒะฟะธั
ะฝััั{}, // ะะฐะผะฐ ะฒะฟะธั
ะฝัะปะฐ ะบะฐััััะปั ะฒ ั
ะพะปะพะดะธะปัะฝะธะบ
rus_verbs:ะฒะฟะธั
ะฝััััั{}, // ะะฐััััะปั ะฒะฟะธั
ะฝัะปะฐัั ะฒ ั
ะพะปะพะดะธะปัะฝะธะบ
rus_verbs:ะฒะฟะปะฐะฒะธัััั{}, // ะัะพะฒะพะด ะฒะฟะปะฐะฒะธะปัั ะฒ ะฟะปะฐัั
rus_verbs:ะฒะฟะปะตัะฝััั{}, // ะฒะฟะปะตัะฝััั ะบัะฐัะธัะตะปั ะฒ ะฑะฐะบ
rus_verbs:ะฒะฟะปะตััะธ{}, // ะฒะฟะปะตััะธ ะปะตะฝัั ะฒ ะฒะพะปะพัั
rus_verbs:ะฒะฟะปะตััะธัั{}, // ะฒะฟะปะตััะธัั ะฒ ะฒะพะปะพัั
rus_verbs:ะฒะฟะปะตัะฐัั{}, // ะฒะฟะปะตัะฐัั ะปะตะฝัั ะฒ ะฒะพะปะพัั
rus_verbs:ะฒะฟะปัะฒะฐัั{}, // ะบะพัะฐะฑะปั ะฒะฟะปัะฒะฐะตั ะฒ ะฟะพัั
rus_verbs:ะฒะฟะปััั{}, // ัั
ัะฐ ะฒะฟะปัะปะฐ ะฒ ะฑัั
ัั
rus_verbs:ะฒะฟะพะปะทะฐัั{}, // ะดัะฐะบะพะฝ ะฒะฟะพะปะทะฐะตั ะฒ ะฟะตัะตัั
rus_verbs:ะฒะฟะพะปะทัะธ{}, // ะดัะฐะบะพะฝ ะฒะฟะพะปะท ะฒ ัะฒะพั ะฟะตัะตัั
rus_verbs:ะฒะฟะพัั
ะฝััั{}, // ะฑะฐะฑะพัะบะฐ ะฒะฟะพัั
ะฝัะปะฐ ะฒ ะพะบะฝะพ
rus_verbs:ะฒะฟัะตััะพะฒะฐัั{}, // ะฒะฟัะตััะพะฒะฐัั ะดะตัะฐะปั ะฒ ะฟะปะธัั
rus_verbs:ะฒะฟัะตััะพะฒะฐัััั{}, // ะฒะฟัะตััะพะฒะฐัััั ะฒ ะฟะปะธัั
rus_verbs:ะฒะฟัะตััะพะฒัะฒะฐัั{}, // ะฒะฟัะตััะพะฒัะฒะฐัั ะดะตัะฐะปั ะฒ ะฟะปะธัั
rus_verbs:ะฒะฟัะตััะพะฒัะฒะฐัััั{}, // ะฒะฟัะตััะพะฒัะฒะฐัััั ะฒ ะฟะปะธัั
rus_verbs:ะฒะฟััะณะธะฒะฐัั{}, // ะะฐััะฐะถะธั ะฒะฟััะณะธะฒะฐะตั ะฒ ะฒะฐะณะพะฝ
rus_verbs:ะฒะฟััะณะฝััั{}, // ะะฐััะฐะถะธั ะฒะฟััะณะฝัะป ะฒ ะฒะฐะณะพะฝ
rus_verbs:ะฒะฟัััะบะธะฒะฐัั{}, // ะคะพัััะฝะบะฐ ะฒะฟัััะบะธะฒะฐะตั ัะพะฟะปะธะฒะพ ะฒ ัะธะปะธะฝะดั
rus_verbs:ะฒะฟัััะบะธะฒะฐัััั{}, // ะขะพะฟะปะธะฒะพ ะฒะฟัััะบะธะฒะฐะตััั ัะพัััะฝะบะพะน ะฒ ัะธะปะธะฝะดั
rus_verbs:ะฒะฟัััะฝััั{}, // ะคะพัััะฝะบะฐ ะฒะฟัััะฝัะปะฐ ัะพะฟะปะธะฒะฝัั ัะผะตัั ะฒ ะบะฐะผะตัั ัะณะพัะฐะฝะธั
rus_verbs:ะฒะฟััะณะฐัั{}, // ะฒะฟััะณะฐัั ะปะพัะฐะดั ะฒ ัะตะปะตะณั
rus_verbs:ะฒะฟััะณะฐัััั{}, // ะฒะฟััะณะฐัััั ะฒ ัะฐะฑะพัั
rus_verbs:ะฒะฟัััั{}, // ะฒะฟัััั ะปะพัะฐะดั ะฒ ัะตะปะตะณั
rus_verbs:ะฒะฟัััััั{}, // ะฒะฟัััััั ะฒ ัะฐะฑะพัั
rus_verbs:ะฒะฟััะบะฐัั{}, // ะฒะฟััะบะฐัั ะฟะพัะตัะธัะตะปะตะน ะฒ ะผัะทะตะน
rus_verbs:ะฒะฟััะบะฐัััั{}, // ะฒะฟััะบะฐัััั ะฒ ะฟะพะผะตัะตะฝะธะต
rus_verbs:ะฒะฟัััะธัั{}, // ะฒะฟัััะธัั ะฟะพัะตัะธัะตะปะตะน ะฒ ะผัะทะตะน
rus_verbs:ะฒะฟััะฐัั{}, // ะฒะฟััะฐัั ะบะพะณะพ-ัะพ ะฒะพ ััะพ-ัะพ
rus_verbs:ะฒะฟััะฐัััั{}, // ะฒะฟััะฐัััั ะฒะพ ััะพ-ัะพ
rus_verbs:ะฒะฟัััะฒะฐัั{}, // ะฒะฟัััะฒะฐัั ะบะพะณะพ-ัะพ ะฒะพ ััะพ-ัะพ
rus_verbs:ะฒะฟัััะฒะฐัััั{}, // ะฒะฟัััะฒะฐัััั ะฒะพ ััะพ-ัะพ
rus_verbs:ะฒัะฐะฑะฐััะฒะฐัััั{}, // ะฒัะฐะฑะฐััะฒะฐัััั ะฒ ัะตะถะธะผ
rus_verbs:ะฒัะฐะฑะพัะฐัััั{}, // ะฒัะฐะฑะพัะฐัััั ะฒ ัะตะถะธะผ
rus_verbs:ะฒัะฐััะฐัั{}, // ะฒัะฐััะฐัั ะฒ ะบะพะถั
rus_verbs:ะฒัะฐััะธ{}, // ะฒัะฐััะธ ะฒ ะบะพะถั
ะธะฝัะธะฝะธัะธะฒ:ะฒัะตะทะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฒัะตะทะฐัั ะทะฐะผะพะบ ะฒ ะดะฒะตัั
ะธะฝัะธะฝะธัะธะฒ:ะฒัะตะทะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะณะปะฐะณะพะป:ะฒัะตะทะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะณะปะฐะณะพะป:ะฒัะตะทะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะฒัะตะทะฐั{},
ะดะตะตะฟัะธัะฐััะธะต:ะฒัะตะทะฐะฒ{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒัะตะทะฐะฝะฝัะน{},
ะธะฝัะธะฝะธัะธะฒ:ะฒัะตะทะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฒัะตะทะฐัััั ะฒ ััะตะฝั
ะธะฝัะธะฝะธัะธะฒ:ะฒัะตะทะฐัััั{ ะฒะธะด:ัะพะฒะตัั },
ะณะปะฐะณะพะป:ะฒัะตะทะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะฒัะตะทะฐััั{},
ะดะตะตะฟัะธัะฐััะธะต:ะฒัะตะทะฐะฒัะธัั{},
rus_verbs:ะฒััะฑะธัั{}, // ะฒััะฑะธัั ะฒ ะฝะฐะณััะทะบั
rus_verbs:ะฒััะฒะฐัััั{}, // ะฒััะฒะฐัััั ะฒ ะทะดะฐะฝะธะต
rus_verbs:ะทะฐะบะฐัะธะฒะฐัั{}, // ะะฐัะพั ะทะฐะบะฐัะธะฒะฐะตั ัะพะฟะปะธะฒะพ ะฒ ะฑะฐะบ
rus_verbs:ะฒะฒะตะทัะธ{}, // ะัะตะดะฟัะธััะธะต ะฒะฒะตะทะปะพ ัะพะฒะฐั ะฒ ัััะฐะฝั
rus_verbs:ะฒะฒะตัััะฐัั{}, // ะะธะทะฐะนะฝะตั ะฒะฒะตัััะฐะป ะฑะปะพะบ ะฒ ัััะฐะฝะธัั
rus_verbs:ะฒะฒะตััััะฒะฐัั{}, // ะะธะทะฐะนะฝะตั ั ัััะดะพะผ ะฒะฒะตััััะฒะฐะตั ะฑะปะพะบะธ ะฒ ัััะฐะฝะธัั
rus_verbs:ะฒะฒะตััััะฒะฐัััั{}, // ะะปะพะบ ััะถะตะปะพ ะฒะฒะตััััะฒะฐะตััั ะฒ ััั ัััะฐะฝะธัั
rus_verbs:ะฒะฒะธะฒะฐัั{}, // ะะตะฝัะธะฝะฐ ะฒะฒะธะฒะฐะตั ะฟะพะปะพัะบั ะฒ ะบะพัั
rus_verbs:ะฒะฒะพะปะฐะบะธะฒะฐัััั{}, // ะะพะนะผะฐะฝะฝะฐั ะผััั ะฒะฒะพะปะฐะบะธะฒะฐะตััั ะบะพัะธะบะพะผ ะฒ ะดะพะผ
rus_verbs:ะฒะฒะพะปะพัั{}, // ะะพั ะฒะฒะพะปะพะบ ะฒ ะดะพะผ ะฟะพะนะผะฐะฝะฝัั ะบัััั
rus_verbs:ะฒะดะตัะณะธะฒะฐัั{}, // ะฟัะธัะฟะพัะพะฑะปะตะฝะธะต ะฒะดะตัะณะธะฒะฐะตั ะฝะธัะบั ะฒ ะธะณะพะปัะฝะพะต ััะบะพ
rus_verbs:ะฒะดะตัะฝััั{}, // ะฟัะธัะฟะพัะพะฑะปะตะฝะธะต ะฒะดะตัะฝัะปะพ ะฝะธัะบั ะฒ ะธะณะพะปัะฝะพะต ััะบะพ
rus_verbs:ะฒะดัะฒะฐัั{}, // ะงะตะปะพะตะบ ะฒะดัะฒะฐะตั ะฒะพะทะดัั
ะฒ ะปะตะณะบะธะต ะฒัะพัะพะณะพ ัะตะปะพะฒะตะบะฐ
rus_verbs:ะฒะดัะฒะฐัััั{}, // ะะพะทะดัั
ะฒะดัะฒะฐะตััั ะฒ ะปะตะณะบะธะต ัะตะปะพะฒะตะบะฐ
rus_verbs:ะฒะปะฐะผัะฒะฐัััั{}, // ะะพะปะธัะธั ะฒะปะฐะผัะฒะฐะตััั ะฒ ะบะฒะฐััะธัั
rus_verbs:ะฒะพะฒะปะตะบะฐัััั{}, // ัััะดะฝัะต ะฟะพะดัะพััะบะธ ะฒะพะฒะปะตะบะฐัััั ะฒ ะทะฐะฝััะธะต ัะฟะพััะพะผ
rus_verbs:ะฒะพะฒะปะตัั{}, // ะฒะพะฒะปะตัั ัััะดะฝัั
ะฟะพะดัะพััะบะพะฒ ะฒ ะทะฐะฝััะธะต ัะฟะพััะพะผ
rus_verbs:ะฒะพะฒะปะตัััั{}, // ะฒะพะฒะปะตัััั ะฒ ะทะฐะฝััะธะต ัะฟะพััะพะผ
rus_verbs:ัะฟัััะธัััั{}, // ัะฟัััะธัััั ะฒ ะฟะพะดะฒะฐะป
rus_verbs:ัะฟััะบะฐัััั{}, // ัะฟััะบะฐัััั ะฒ ะฟะพะดะฒะฐะป
rus_verbs:ะพัะฟัะฐะฒะปััััั{}, // ะพัะฟัะฐะฒะปััััั ะฒ ะดะฐะปัะฝะตะต ะฟะปะฐะฒะฐะฝะธะต
ะธะฝัะธะฝะธัะธะฒ:ัะผะธัะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ะะพะฒะตัั
ะฝะพััั ัะผะธัะธััะตั ัะปะตะบััะพะฝั ะฒ ะฟัะพัััะฐะฝััะฒะพ
ะธะฝัะธะฝะธัะธะฒ:ัะผะธัะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะณะปะฐะณะพะป:ัะผะธัะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะณะปะฐะณะพะป:ัะผะธัะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ัะผะธัะธััั{},
ะดะตะตะฟัะธัะฐััะธะต:ัะผะธัะธัะพะฒะฐะฒ{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะผะธัะธัะพะฒะฐะฒัะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะผะธัะธัะพะฒะฐะฒัะธะน{ ะฒะธะด:ัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะผะธัะธััััะธะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะผะธัะธััะตะผัะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะผะธัะธัะพะฒะฐะฝะฝัะน{},
ะธะฝัะธะฝะธัะธะฒ:ััะฐะฟะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะัะตัััะฟะฝะธะบะฐ ััะฐะฟะธัะพะฒะฐะปะธ ะฒ ะบะพะปะพะฝะธั
ะธะฝัะธะฝะธัะธะฒ:ััะฐะฟะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะณะปะฐะณะพะป:ััะฐะฟะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ััะฐะฟะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ััะฐะฟะธััั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ััะฐะฟะธััะตะผัะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ััะฐะฟะธัะพะฒะฐะฝะฝัะน{},
rus_verbs:ััะฐะฟะธัะพะฒะฐัััั{}, // ะัะตัััะฟะฝะธะบะธ ััะฐะฟะธัััััั ะฒ ะบะพะปะพะฝะธั
rus_verbs:ะฑะฐะปะปะพัะธัะพะฒะฐัััั{}, // ะพะฝะธ ะฑะฐะปะปะพัะธัะพะฒะฐะปะธัั ะฒ ะถััะธ
rus_verbs:ะฑะตะถะฐัั{}, // ะะปะธะณะฐัั
ั ัะตะผัะตะน ะปัะฑะพะฒะฝะธัั ะฑะตะถะฐะป ะฒ ะดััะณัั ัััะฐะฝั
rus_verbs:ะฑัะพัะฐัั{}, // ะะฝะธ ะฑัะพัะฐะปะธ ะฒ ัะพะฝัะฐะฝ ะผะตะดะฝัะต ะผะพะฝะตัะบะธ
rus_verbs:ะฑัะพัะฐัััั{}, // ะะตัะธ ะฑัะพัะฐะปะธัั ะฒ ะฒะพะดั ั ะผะพััะฐ
rus_verbs:ะฑัะพัะธัั{}, // ะะฝ ะฑัะพัะธะป ะฒ ัะพะฝัะฐะฝ ะผะตะดะฝัั ะผะพะฝะตัะบั
rus_verbs:ะฑัะพัะธัััั{}, // ัะฐะผะพัะฑะธะนัะฐ ะฑัะพัะธะปัั ั ะผะพััะฐ ะฒ ะฒะพะดั
rus_verbs:ะฟัะตะฒัะฐัะธัั{}, // ะะฐะนะดะตะฝ ะฑะตะปะพะบ, ะบะพัะพััะน ะฟัะตะฒัะฐัะธั ัะตะปะพะฒะตะบะฐ ะฒ ััะฟะตัะณะตัะพั
rus_verbs:ะฑัะบัะธัะพะฒะฐัั{}, // ะัะบัะธั ะฑัะบัะธััะตั ัะฐะฝะบะตั ะฒ ะฟะพัั
rus_verbs:ะฑัะบัะธัะพะฒะฐัััั{}, // ะกัั
ะพะณััะท ะฑัะบัะธััะตััั ะฒ ะฟะพัั
rus_verbs:ะฒะฑะตะณะฐัั{}, // ะัััะตั ะฒะฑะตะณะฐะตั ะฒ ะดะฒะตัั
rus_verbs:ะฒะฑะตะถะฐัั{}, // ะัััะตั ะฒะฑะตะถะฐะป ะฒ ะดะฒะตัั
rus_verbs:ะฒะฑะตัะพะฝะธัะพะฒะฐัั{}, // ะะฟะพัะฐ ะฑัะปะฐ ะฒะฑะตัะพะฝะธัะพะฒะฐะฝะฐ ะฒ ะฟะพะป
rus_verbs:ะฒะฑะธะฒะฐัั{}, // ะะฐััะตั ะฒะฑะธะฒะฐะตั ััััั ะฒ ะฟะปะธัั
rus_verbs:ะฒะฑะธะฒะฐัััั{}, // ะจัััั ะฒะฑะธะฒะฐะตััั ะฒ ะฟะปะธัั
rus_verbs:ะฒะฑะธัะฐัั{}, // ะะฐัะฐ ะฒะฑะธัะฐะตั ะฒ ัะตะฑั ะฒะปะฐะณั
rus_verbs:ะฒะฑะธัั{}, // ะฃัะตะฝะธะบ ะฒะฑะธะป ะฒ ะดะพัะบั ะผะฐะปะตะฝัะบะธะน ะณะฒะพะทะดั
rus_verbs:ะฒะฑัะฐััะฒะฐัั{}, // ะัะฑะธัั ะฒะฑัะฐััะฒะฐะตั ะผัั ะฒ ะธะณัั
rus_verbs:ะฒะฑัะฐััะฒะฐัััั{}, // ะัั ะฒะฑัะฐััะฒะฐะตััั ะฒ ะธะณัั
rus_verbs:ะฒะฑัะพัะธัั{}, // ะกัะดัั ะฒะฑัะพัะธะป ะผัั ะฒ ะธะณัั
rus_verbs:ะฒะฑััะฐะฒะธัััั{}, // ะกะฒะตัะปะพ ะฒะฑััะฐะฒะธะปะพัั ะฒ ะฑะตัะพะฝ
rus_verbs:ะฒะฑััะฐะฒะปะธะฒะฐัััั{}, // ะกะฒะตัะปะพ ะฒะฑััะฐะฒะปะธะฒะฐะตััั ะฒ ะฑะตัะพะฝ
rus_verbs:ะฒะฑัั
ะธะฒะฐัััั{}, // ะะฝะพะณะพ ะดะตะฝะตะณ ะฒะฑัั
ะธะฒะฐัััั ะฒ ััะพั ะฟัะพะตะบั
rus_verbs:ะฒะฒะฐะปะธะฒะฐัััั{}, // ะงะตะปะพะฒะตะบ ะฒะฒะฐะปะธะฒะฐะตััั ะฒ ะบะฐะฑะธะฝะตั ะฒัะฐัะฐ
rus_verbs:ะฒะฒะฐะปะธัั{}, // ะััะทัะธะบะธ ะฒะฒะฐะปะธะปะธ ะผะตัะพะบ ะฒ ะบะฒะฐััะธัั
rus_verbs:ะฒะฒะฐะปะธัััั{}, // ะงะตะปะพะฒะตะบ ะฒะฒะฐะปะธะปัั ะฒ ะบะฐะฑะธะฝะตั ัะตัะฐะฟะตะฒัะฐ
rus_verbs:ะฒะฒะฐัะธะฒะฐัั{}, // ะ ะพะฑะพั ะฒะฒะฐัะธะฒะฐะตั ะฐัะผะฐัััะธะฝั ะฒ ะฟะปะธัั
rus_verbs:ะฒะฒะฐัะธะฒะฐัััั{}, // ะัะผะฐัััะฐ ะฒะฒะฐัะธะฒะฐะตััั ะฒ ะฟะปะธัั
rus_verbs:ะฒะฒะฐัะธัั{}, // ะ ะพะฑะพั ะฒะฒะฐัะธะป ะฐัะผะฐัััะธะฝั ะฒ ะฟะปะธัั
rus_verbs:ะฒะปะตะทัั{}, // ะัะตะดะฟัะธััะธะต ะฒะฒะตะทะปะพ ัะพะฒะฐั ะฒ ัััะฐะฝั
rus_verbs:ะฒะฒะตัะฝััั{}, // ะะฒะตัะฝะธ ะฝะพะฒัั ะปะฐะผะฟะพัะบั ะฒ ะปััััั
rus_verbs:ะฒะฒะตัะฝััััั{}, // ะะฐะผะฟะพัะบะฐ ะปะตะณะบะพ ะฒะฒะตัะฝัะปะฐัั ะฒ ะฟะฐััะพะฝ
rus_verbs:ะฒะฒะตัััะฒะฐัั{}, // ะญะปะตะบััะธะบ ะฒะฒะตัััะฒะฐะตั ะปะฐะผะฟะพัะบั ะฒ ะฟะฐััะพะฝ
rus_verbs:ะฒะฒะตัััะฒะฐัััั{}, // ะะฐะผะฟะพัะบะฐ ะปะตะณะบะพ ะฒะฒะตัััะฒะฐะตััั ะฒ ะฟะฐััะพะฝ
rus_verbs:ะฒะฒะตัััั{}, // ะะฐัะธะตะฝั ะฒะฒะตััะตั ัะฒะพั ะถะธะทะฝั ะฒ ััะบะธ ะฒัะฐัะฐ
rus_verbs:ะฒะฒะตัััััั{}, // ะะฐัะธะตะฝั ะฒะฒะตััะตััั ะฒ ััะบะธ ะฒัะฐัะฐ
rus_verbs:ะฒะฒะตััะธ{}, // ะะณะตะฝััะฒะพ ะฒะฒะตะปะพ ัะฒะพะตะณะพ ะฟัะตะดััะฐะฒะธัะตะปั ะฒ ัะพะฒะตั ะดะธัะตะบัะพัะพะฒ
rus_verbs:ะฒะฒะธะฒะฐัััั{}, // ะฟะพะปะพัะบะฐ ะฒะฒะธะฒะฐะตััั ะฒ ะบะพัั
rus_verbs:ะฒะฒะธะฝัะธัั{}, // ะัะฒะตััะบะฐ ะฒะฒะธะฝัะธะปะฐ ััััะฟ ะฒ ะดะตัะตะฒะพ
rus_verbs:ะฒะฒะธะฝัะธัััั{}, // ะจัััะฟ ะฒะฒะธะฝัะธะปัั ะฒ ะดะตัะตะฒะพ
rus_verbs:ะฒะฒะธะฝัะธะฒะฐัั{}, // ะ ัะบะฐ ะฒะฒะธะฝัะธะฒะฐะตั ัะฐะผะพัะตะท ะฒ ััะตะฝั
rus_verbs:ะฒะฒะธะฝัะธะฒะฐัััั{}, // ะกะฐะผะพัะตะท ะฒะฒะธะฝัะธะฒะฐะตััั ะฒ ััะตะฝั
rus_verbs:ะฒะฒะพะดะธัั{}, // ะะณะตะฝััะฒะพ ะฒะฒะพะดะธั ัะฒะพะตะณะพ ะฟัะตะดััะฐะฒะธัะตะปั ะฒ ัะพะฒะตั ะดะธัะตะบัะพัะพะฒ
rus_verbs:ะฒะฒะพะดะธัััั{}, // ะัะตะดััะฐะฒะธัะตะปั ะฐะณะตะฝััะฒะฐ ะฒะฒะพะดะธััั ะฒ ัะพะฒะตั ะดะธัะตะบัะพัะพะฒ
// rus_verbs:ะฒะฒะพะทะธัั{}, // ะคะธัะผะฐ ะฒะฒะพะทะธั ะฒ ัััะฐะฝั ััะฐะฝะบะธ ะธ ััััะต
rus_verbs:ะฒะฒะพะทะธัััั{}, // ะกัะฐะฝะบะธ ะธ ััััะต ะฒะฒะพะทัััั ะฒ ัััะฐะฝั
rus_verbs:ะฒะฒะพะปะฐะบะธะฒะฐัั{}, // ะะพะนะผะฐะฝะฝะฐั ะผััั ะฒะฒะพะปะฐะบะธะฒะฐะตััั ะบะพัะธะบะพะผ ะฒ ะดะพะผ
rus_verbs:ะฒะฒะพัะฐัะธะฒะฐัั{}, // ะญะปะตะบััะธะบ ะฒะฒะพัะฐัะธะฒะฐะตั ะฝะพะฒัั ะปะฐะผะฟะพัะบั ะฒ ะฟะฐััะพะฝ
rus_verbs:ะฒะฒะพัะฐัะธะฒะฐัััั{}, // ะะพะฒะฐั ะปะฐะผะฟะพัะบะฐ ะปะตะณะบะพ ะฒะฒะพัะฐัะธะฒะฐะตััั ะฒ ะฟะฐััะพะฝ
rus_verbs:ะฒะฒัะทะฐัััั{}, // ะ ะฐะทะฒะตะดัะพัะฐ ะฒะฒัะทะฐะปะฐัั ะฒ ะฑะพะน
rus_verbs:ะฒะฒัะทัะฒะฐัััั{}, // ะะตัะตะดะพะฒัะต ัะฐััะธ ะฒะฒัะทัะฒะฐัััั ะฒ ะฑะพะน
rus_verbs:ะฒะณะปัะดะตัััั{}, // ะั
ัะฐะฝะฝะธะบ ะฒะณะปัะดะตะปัั ะฒ ัะตะผะฝัะน ะบะพัะธะดะพั
rus_verbs:ะฒะณะปัะดัะฒะฐัััั{}, // ะั
ัะฐะฝะฝะธะบ ะฒะฝะธะผะฐัะตะปัะฝะพ ะฒะณะปัะดัะฒะฐะตััั ะฒ ะผะพะฝะธัะพั
rus_verbs:ะฒะณะพะฝััั{}, // ะญัะฐ ะผัะทัะบะฐ ะฒะณะพะฝัะตั ะผะตะฝั ะฒ ะดะตะฟัะตััะธั
rus_verbs:ะฒะณััะทะฐัััั{}, // ะะพะฝะด ะฒะณััะทะฐะตััั ะฒ ะฟะพะฒะตัั
ะฝะพััั ะฐััะตัะพะธะดะฐ
rus_verbs:ะฒะณััะทัััั{}, // ะะพะฝะด ะฒะณััะทัั ะฒ ะฟะพะฒะตัั
ะฝะพััั ะฐััะตัะพะธะดะฐ
rus_verbs:ะฒะดะฐะฒะฐัััั{}, // ะั ะฝะต ะดะพะปะถะฝั ะฒะดะฐะฒะฐัััั ะฒ ััะธะดะธัะตัะบะธะต ะดะตัะฐะปะธ
rus_verbs:ะฒะดะฒะธะณะฐัั{}, // ะ ะพะฑะพั ะฒะดะฒะธะณะฐะตั ะบะพะฝัะตะนะฝะตั ะฒ ััะตะนะบั
rus_verbs:ะฒะดะฒะธะณะฐัััั{}, // ะะพะฝัะตะนะฝะตั ะฒะดะฒะธะณะฐะตััั ะฒ ััะตะนะบั
rus_verbs:ะฒะดะฒะธะฝััั{}, // ะผะฐะฝะธะฟัะปััะพั ะฒะดะฒะธะฝัะป ะดะตัะฐะปั ะฒ ะฟะตัั
rus_verbs:ะฒะดะฒะธะฝััััั{}, // ะดะตัะฐะปั ะฒะดะฒะธะฝัะปะฐัั ะฒ ะฟะตัั
rus_verbs:ะฒะดะตะฒะฐัั{}, // ะฟะพััะฝะธั
ะฐ ะฑััััะพ ะฒะดะตะฒะฐะตั ะฝะธัะบั ะฒ ะธะณะพะปะบั
rus_verbs:ะฒะดะตะฒะฐัััั{}, // ะฝะธัะบะฐ ะฑััััะพ ะฒะดะตะฒะฐะตััั ะฒ ะธะณะพะปัะฝะพะต ััะบะพ
rus_verbs:ะฒะดะตัั{}, // ะฟะพััะฝะธั
ะฐ ะฑััััะพ ะฒะดะตะปะฐ ะฝะธัะบั ะฒ ะธะณะพะปัะฝะพะต ััะบะพ
rus_verbs:ะฒะดะตัััั{}, // ะฝะธัะบะฐ ะฑััััะพ ะฒะดะตะปะฐัั ะฒ ะธะณะพะปัะฝะพะต ััะบะพ
rus_verbs:ะฒะดะตะปะฐัั{}, // ะผะฐััะตั ะฒะดะตะปะฐะป ัะพะทะตัะบั ะฒ ััะตะฝั
rus_verbs:ะฒะดะตะปัะฒะฐัั{}, // ะผะฐััะตั ะฒะดะตะปัะฒะฐะตั ะฒัะบะปััะฐัะตะปั ะฒ ััะตะฝั
rus_verbs:ะฒะดะตะปัะฒะฐัััั{}, // ะบัะพะฝััะตะนะฝ ะฒะดะตะปัะฒะฐะตััั ะฒ ััะตะฝั
rus_verbs:ะฒะดะตัะณะธะฒะฐัััั{}, // ะฝะธัะบะฐ ะปะตะณะบะพ ะฒะดะตัะณะธะฒะฐะตััั ะฒ ะธะณะพะปัะฝะพะต ััะบะพ
rus_verbs:ะฒะดะตัะฝััััั{}, // ะฝะธัะบะฐ ะปะตะณะบะพ ะฒะดะตัะฝัะปะฐัั ะฒ ะธะณะพะปัะฝะพะต ััะบะพ
rus_verbs:ะฒะดะพะปะฑะธัั{}, // ะะผะตัะธะบะฐะฝัั ะพะฑะตัะฐะปะธ ะฒะดะพะปะฑะธัั ัััะฐะฝั ะฒ ะบะฐะผะตะฝะฝัะน ะฒะตะบ
rus_verbs:ะฒะดัะผัะฒะฐัััั{}, // ะะฐะปััะธะบ ะพะฑััะฝะพ ะฝะต ะฒะดัะผัะฒะฐะปัั ะฒ ััะถะตั ัะธะปัะผะพะฒ
rus_verbs:ะฒะดัั
ะฐัั{}, // ะผั ะฒะดัั
ะฐะตะผ ะฒ ัะตะฑั ะฒะตัั ััะพั ัะผะพะณ
rus_verbs:ะฒะดัั
ะฐัััั{}, // ะะตัั ััะพั ัะผะพะณ ะฒะดัั
ะฐะตััั ะฒ ะปะตะณะบะธะต
rus_verbs:ะฒะตัะฝััั{}, // ะะฝะธะณั ะฝะฐะดะพ ะฒะตัะฝััั ะฒ ะฑะธะฑะปะธะพัะตะบั
rus_verbs:ะฒะตัะฝััััั{}, // ะะตัะธ ะฒะตัะฝัะปะธัั ะฒ ะฑะธะฑะปะธะพัะตะบั
rus_verbs:ะฒะถะฐัััั{}, // ะะพะดะธัะตะปั ะฒะถะฐะปัั ะฒ ะบัะตัะปะพ
rus_verbs:ะฒะถะธะฒะฐัััั{}, // ะะบัะตั ะฒะถะธะฒะฐะตััั ะฒ ะฝะพะฒัั ัะพะปั
rus_verbs:ะฒะถะธะฒะธัั{}, // ะัะฐัะธ ะฒะถะธะฒะธะปะธ ััะธะผัะปััะพั ะฒ ัะตะปะพ ะฟะฐัะธะตะฝัะฐ
rus_verbs:ะฒะถะธะฒะธัััั{}, // ะกัะธะผัะปััะพั ะฒะถะธะฒะธะปัั ะฒ ัะตะปะพ ะฟะฐัะธะตะฝัะฐ
rus_verbs:ะฒะถะธะฒะปััั{}, // ะัะฐัะธ ะฒะถะธะฒะปััั ััะธะผัะปััะพั ะฒ ัะตะปะพ ะฟะฐัะธะตะฝัะฐ
rus_verbs:ะฒะถะธะฒะปััััั{}, // ะกัะธะผัะปััะพั ะฒะถะธะฒะปัะตััั ะฒ ัะตะปะพ
rus_verbs:ะฒะถะธะผะฐัััั{}, // ะะธะดะธัะตะปั ะธะฝััะธะฝะบัะธะฒะฝะพ ะฒะถะธะผะฐะตััั ะฒ ะบัะตัะปะพ
rus_verbs:ะฒะถะธัััั{}, // ะะบัะตั ะฒะถะธะปัั ะฒ ัะฒะพั ะฝะพะฒัั ัะพะปั
rus_verbs:ะฒะทะฒะธะฒะฐัััั{}, // ะะพะทะดััะฝัะน ัะฐัะธะบ ะฒะทะฒะธะฒะฐะตััั ะฒ ะฝะตะฑะพ
rus_verbs:ะฒะทะฒะธะฝัะธัั{}, // ะัะธะทะธั ะฒะทะฒะธะฝัะธะป ัะตะฝั ะฒ ะฝะตะฑะพ
rus_verbs:ะฒะทะฒะธะฝัะธัััั{}, // ะฆะตะฝั ะฒะทะฒะธะฝัะธะปะธัั ะฒ ะฝะตะฑะพ
rus_verbs:ะฒะทะฒะธะฝัะธะฒะฐัั{}, // ะัะธะทะธั ะฒะทะฒะธะฝัะธะฒะฐะตั ัะตะฝั ะฒ ะฝะตะฑะพ
rus_verbs:ะฒะทะฒะธะฝัะธะฒะฐัััั{}, // ะฆะตะฝั ะฒะทะฒะธะฝัะธะฒะฐัััั ะฒ ะฝะตะฑะพ
rus_verbs:ะฒะทะฒะธัััั{}, // ะจะฐัะธะบะธ ะฒะทะฒะธะปะธัั ะฒ ะฝะตะฑะพ
rus_verbs:ะฒะทะปะตัะฐัั{}, // ะญะบัะฟะตัะธะผะตะฝัะฐะปัะฝัะน ะฐะฟะฟะฐัะฐั ะฒะทะปะตัะฐะตั ะฒ ะฒะพะทะดัั
rus_verbs:ะฒะทะปะตัะตัั{}, // ะญะบัะฟะตัะธะผะตะฝัะฐะปัะฝัะน ะฐะฟะฟะฐัะฐั ะฒะทะปะตัะตะป ะฒ ะฝะตะฑะพ
rus_verbs:ะฒะทะผัะฒะฐัั{}, // ัะฐัะธะบะธ ะฒะทะผัะฒะฐัั ะฒ ะฝะตะฑะพ
rus_verbs:ะฒะทะผััั{}, // ะจะฐัะธะบะธ ะฒะทะผัะปะธ ะฒ ะฝะตะฑะพ
rus_verbs:ะฒะธะปัะฝััั{}, // ะะฐัะธะฝะฐ ะฒะธะปัะฝัะปะฐ ะฒ ะปะตะฒัั ััะพัะพะฝั
rus_verbs:ะฒะบะฐะปัะฒะฐัั{}, // ะะตะดัะตัััะฐ ะฒะบะฐะปัะฒะฐะตั ะธะณะปั ะฒ ะฒะตะฝั
rus_verbs:ะฒะบะฐะปัะฒะฐัััั{}, // ะะณะปะฐ ะฒะบะฐะปัะฒะฐัััั ะฟััะผะพ ะฒ ะฒะตะฝั
rus_verbs:ะฒะบะฐะฟัะฒะฐัั{}, // ัะฐะฑะพัะธะน ะฒะบะฐะฟัะฒะฐะตั ัะฒะฐั ะฒ ะทะตะผะปั
rus_verbs:ะฒะบะฐะฟัะฒะฐัััั{}, // ะกะฒะฐั ะฒะบะฐะฟัะฒะฐะตััั ะฒ ะทะตะผะปั
rus_verbs:ะฒะบะฐัะธัั{}, // ัะฐะฑะพัะธะต ะฒะบะฐัะธะปะธ ะฑะพัะบั ะฒ ะณะฐัะฐะถ
rus_verbs:ะฒะบะฐัะธัััั{}, // ะผะฐัะธะฝะฐ ะฒะบะฐัะธะปะฐัั ะฒ ะณะฐัะฐะถ
rus_verbs:ะฒะบะฐััะฒะฐัั{}, // ัะฐะฑะพัะธะบ ะฒะบะฐััะฒะฐัั ะฑะพัะบั ะฒ ะณะฐัะฐะถ
rus_verbs:ะฒะบะฐััะฒะฐัััั{}, // ะผะฐัะธะฝะฐ ะฒะบะฐััะฒะฐะตััั ะฒ ะณะฐัะฐะถ
rus_verbs:ะฒะบะฐัะฐัั{}, // ะะตั
ะฐะฝะธะบะธ ะฒะบะฐัะฐะปะธ ะฒ ะฑะฐะบ ะผะฝะพะณะพ ัะพะฟะปะธะฒะฐ
rus_verbs:ะฒะบะฐัะธะฒะฐัั{}, // ะะฐัะพั ะฒะบะฐัะธะฒะฐะตั ัะพะฟะปะธะฒะพ ะฒ ะฑะฐะบ
rus_verbs:ะฒะบะฐัะธะฒะฐัััั{}, // ะขะพะฟะปะธะฒะพ ะฒะบะฐัะธะฒะฐะตััั ะฒ ะฑะฐะบ
rus_verbs:ะฒะบะธะดะฐัั{}, // ะะฐะฝะธะฟัะปััะพั ะฒะบะธะดะฐะป ะณััะท ะฒ ะบะพะฝัะตะนะฝะตั
rus_verbs:ะฒะบะธะดัะฒะฐัั{}, // ะะฐะฝะธะฟัะปััะพั ะฒะบะธะดัะฒะฐะตั ะณััะท ะฒ ะบะพะฝัะตะนะฝะตั
rus_verbs:ะฒะบะธะดัะฒะฐัััั{}, // ะััะท ะฒะบะธะดัะฒะฐะตััั ะฒ ะบะพะฝัะตะนะฝะตั
rus_verbs:ะฒะบะปะฐะดัะฒะฐัั{}, // ะะฝะฒะตััะพั ะฒะบะปะฐะดัะฒะฐะตั ะดะตะฝัะณะธ ะฒ ะฐะบัะธะธ
rus_verbs:ะฒะบะปะฐะดัะฒะฐัััั{}, // ะะฝะฒะตััะพั ะฒะบะปะฐะดัะฒะฐะตััั ะฒ ะฐะบัะธะธ
rus_verbs:ะฒะบะปะตะธะฒะฐัั{}, // ะะฐะปััะธะบ ะฒะบะปะตะธะฒะฐะตั ะบะฐััะธะฝะบั ะฒ ัะตััะฐะดั
rus_verbs:ะฒะบะปะตะธะฒะฐัััั{}, // ะะฐััะธะฝะบะฐ ะฒะบะปะตะธะฒะฐะตััั ะฒ ัะตััะฐะดั
rus_verbs:ะฒะบะปะตะธัั{}, // ะะฐะปััะธะบ ะฒะบะปะตะธะป ะบะฐััะธะฝะบั ะฒ ัะตััะฐะดั
rus_verbs:ะฒะบะปะตะธัััั{}, // ะะฐััะธะฝะบะฐ ะฒะบะปะตะธะปะฐัั ะฒ ัะตััะฐะดั
rus_verbs:ะฒะบะปะตะฟะฐัั{}, // ะะพะปะพัะพะบ ะฒะบะปะตะฟะฐะป ะทะฐะบะปะตะฟะบั ะฒ ะปะธัั
rus_verbs:ะฒะบะปะตะฟัะฒะฐัั{}, // ะะพะปะพัะพะบ ะฒะบะปะตะฟัะฒะฐะตั ะทะฐะบะปะตะฟะบั ะฒ ะปะธัั
rus_verbs:ะฒะบะปะธะฝะธะฒะฐัััั{}, // ะะฐัะธะฝะฐ ะฒะบะปะธะฝะธะฒะฐะตััั ะฒ ะฟะพัะพะบ
rus_verbs:ะฒะบะปะธะฝะธัััั{}, // ะผะฐัะธะฝะฐ ะฒะบะปะธะฝะธะปะฐัั ะฒ ะฟะพัะพะบ
rus_verbs:ะฒะบะปััะฐัั{}, // ะะพะผะฐะฝะดะฐ ะฒะบะปััะฐะตั ะบะพะผะฟัััะตั ะฒ ัะตัั
rus_verbs:ะฒะบะปััะฐัััั{}, // ะะฐัะธะฝะฐ ะฒะบะปััะฐะตััั ะฒ ะณะปะพะฑะฐะปัะฝัั ัะตัั
rus_verbs:ะฒะบะปััะธัั{}, // ะะพะผะฐะฝะดะฐ ะฒะบะปััะธะปะฐ ะบะพะผะฟัััะตั ะฒ ัะตัั
rus_verbs:ะฒะบะปััะธัััั{}, // ะะพะผะฟัััะตั ะฒะบะปััะธะปัั ะฒ ัะตัั
rus_verbs:ะฒะบะพะปะฐัะธะฒะฐัั{}, // ะกัะพะปัั ะฒะบะพะปะฐัะธะฒะฐะตั ะณะฒะพะทะดั ะฒ ะดะพัะบั
rus_verbs:ะฒะบะพะปะฐัะธะฒะฐัััั{}, // ะะฒะพะทะดั ะฒะบะพะปะฐัะธะฒะฐะตััั ะฒ ะดะพัะบั
rus_verbs:ะฒะบะพะปะพัะธัั{}, // ะกัะพะปัั ะฒะบะพะปะพัะธะป ะณะฒะพะทะดั ะฒ ะดะพัะบั
rus_verbs:ะฒะบะพะปะพัั{}, // ะะตะดัะตัััะฐ ะฒะบะพะปะพะปะฐ ะฒ ะผัััั ะปะตะบะฐัััะฒะพ
rus_verbs:ะฒะบะพะฟะฐัั{}, // ะ ะฐะฑะพัะธะต ะฒะบะพะฟะฐะปะธ ัะฒะฐั ะฒ ะทะตะผะปั
rus_verbs:ะฒะบัะฐะดัะฒะฐัััั{}, // ะัะธะฑะบะฐ ะฒะบัะฐะดัะฒะฐะตััั ะฒ ัะฐััะตัั
rus_verbs:ะฒะบัะฐะธะฒะฐัั{}, // ะะพััะฝะธั
ะฐ ะฒะบัะฐะธะฒะฐะตั ะฒััะฐะฒะบั ะฒ ัะฑะบั
rus_verbs:ะฒะบัะฐะธะฒะฐัััั{}, // ะััะฐะฒะบะฐ ะฒะบัะฐะธะฒะฐะตััั ะฒ ัะฑะบั
rus_verbs:ะฒะบัะฐััััั{}, // ะัะธะฑะบะฐ ะฒะบัะฐะปะฐัั ะฒ ัะฐััะตัั
rus_verbs:ะฒะบัััะธัั{}, // ะญะปะตะบััะธะบ ะฒะบัััะธะป ะปะฐะผะฟะพัะบั ะฒ ะฟะฐััะพะฝ
rus_verbs:ะฒะบัััะธัััั{}, // ะปะฐะผะฟะพัะบะฐ ะปะตะณะบะพ ะฒะบัััะธะปะฐัั ะฒ ะฟะฐััะพะฝ
rus_verbs:ะฒะบัััะธะฒะฐัั{}, // ะญะปะตะบััะธะบ ะฒะบัััะธะฒะฐะตั ะปะฐะผะฟะพัะบั ะฒ ะฟะฐััะพะฝ
rus_verbs:ะฒะบัััะธะฒะฐัััั{}, // ะะฐะผะฟะพัะบะฐ ะปะตะณะบะพ ะฒะบัััะธะฒะฐะตััั ะฒ ะฟะฐััะพะฝ
rus_verbs:ะฒะปะฐะทะธัั{}, // ะ ะฐะทัะตะผ ะฒะปะฐะทะธั ะฒ ะพัะฒะตัััะฒะธะต
rus_verbs:ะฒะปะฐะผัะฒะฐัั{}, // ะะพะปะธัะธั ะฒะปะฐะผัะฒะฐะตััั ะฒ ะบะฒะฐััะธัั
rus_verbs:ะฒะปะตัะฐัั{}, // ะกะฐะผะพะปะตั ะฒะปะตัะฐะตั ะฒ ะณัะพะทะพะฒะพะน ััะพะฝั
rus_verbs:ะฒะปะตัะตัั{}, // ะกะฐะผะพะปะตั ะฒะปะตัะตะป ะฒ ะณัะพะทะพะฒะพะน ััะพะฝั
rus_verbs:ะฒะปะธะฒะฐัั{}, // ะะตั
ะฐะฝะธะบ ะฒะปะธะฒะฐะตั ะผะฐัะปะพ ะฒ ะบะฐััะตั
rus_verbs:ะฒะปะธะฒะฐัััั{}, // ะะฐัะปะพ ะฒะปะธะฒะฐะตััั ะฒ ะบะฐััะตั
rus_verbs:ะฒะปะธะฟะฐัั{}, // ะญัะธ ะฝะตัะดะฐัะฝะธะบะธ ะฟะพััะพัะฝะฝะพ ะฒะปะธะฟะฐัั ะฒ ัะฐะทะฝัะต ะฟัะพะธััะตััะฒะธั
rus_verbs:ะฒะปะธะฟะฝััั{}, // ะญัะธ ะฝะตัะดะฐัะฝะธะบะธ ะพะฟััั ะฒะปะธะฟะปะธ ะฒ ะฝะตะฟัะธััะฝะพััะธ
rus_verbs:ะฒะปะธัั{}, // ะะตั
ะฐะฝะธะบ ะฒะปะธะป ัะฒะตะถะตะต ะผะฐัะปะพ ะฒ ะบะฐััะตั
rus_verbs:ะฒะปะธัััั{}, // ะกะฒะตะถะตะต ะผะฐัะปะพ ะฒะปะธะปะพัั ะฒ ะฑะฐะบ
rus_verbs:ะฒะปะพะถะธัั{}, // ะะฝะฒะตััะพัั ะฒะปะพะถะธะปะธ ะฒ ััะธ ะฐะบัะธะธ ะฑะพะปััะธะต ััะตะดััะฒะฐ
rus_verbs:ะฒะปะพะถะธัััั{}, // ะะฝะฒะตััะพัั ะฒะปะพะถะธะปะธัั ะฒ ััะธ ะฐะบัะธะธ
rus_verbs:ะฒะปัะฑะธัััั{}, // ะะพะปั ะฒะปัะฑะธะปัั ะฒ ะะปั
rus_verbs:ะฒะปัะฑะปััั{}, // ะะปั ะฟะพััะพัะฝะฝะพ ะฒะปัะฑะปัะปะฐ ะฒ ัะตะฑั ะผะฐะปััะธะบะพะฒ
rus_verbs:ะฒะปัะฑะปััััั{}, // ะะปั ะฒะปัะฑะปัะตััั ะฒ ัะฟะพัััะผะตะฝะพะฒ
rus_verbs:ะฒะปัะฟะฐัััั{}, // ะะพะปั ะฒะปัะฟะฐะปัั ะฒ ะฝะตะฟัะธััะฝะพััั
rus_verbs:ะฒะปัะฟัะฒะฐัััั{}, // ะะพะปั ะฟะพััะพัะฝะฝะพ ะฒะปัะฟัะฒะฐะตััั ะฒ ะฝะตะฟัะธััะฝะพััะธ
rus_verbs:ะฒะผะตะฝะธัั{}, // ะฒะผะตะฝะธัั ะฒ ะฒะธะฝั
rus_verbs:ะฒะผะตะฝััั{}, // ะฒะผะตะฝััั ะฒ ะพะฑัะทะฐะฝะฝะพััั
rus_verbs:ะฒะผะตัะทะฐัั{}, // ะะพะปะตัะฐ ะฒะผะตัะทะฐัั ะฒ ะปะตะด
rus_verbs:ะฒะผะตัะทะฝััั{}, // ะะพะปะตัะฐ ะฒะผะตัะทะปะธ ะฒ ะปะตะด
rus_verbs:ะฒะผะตััะธ{}, // ะฒะผะตััะธ ะฒ ะดะพะผ
rus_verbs:ะฒะผะตััะธัั{}, // ะฒะผะตััะธัั ะฒ ัะผะบะพััั
rus_verbs:ะฒะผะตััะธัััั{}, // ะัะธะฑะพั ะฝะต ะฒะผะตััะธะปัั ะฒ ะทะพะฝะด
rus_verbs:ะฒะผะตัะฐัััั{}, // ะะฐัะฐะปัะฝะธะบ ะฒะผะตัะฐะปัั ะฒ ะบะพะฝัะปะธะบั
rus_verbs:ะฒะผะตัะธะฒะฐัั{}, // ะะต ะฒะผะตัะธะฒะฐะน ะผะตะฝั ะฒ ััะพ ะดะตะปะพ
rus_verbs:ะฒะผะตัะธะฒะฐัััั{}, // ะะฐัะฐะปัะฝะธะบ ะฒะผะตัะธะฒะฐะตััั ะฒ ะฟะตัะตะณะพะฒะพัั
rus_verbs:ะฒะผะตัะฐัััั{}, // ะัะธะฑะพัั ะฝะต ะฒะผะตัะฐัััั ะฒ ะบะพัะฟัั
rus_verbs:ะฒะผะธะฝะฐัั{}, // ะฒะผะธะฝะฐัั ะฒ ะบะพัะฟัั
rus_verbs:ะฒะผะธะฝะฐัััั{}, // ะบัะพะฝััะตะนะฝ ะฒะผะธะฝะฐะตััั ะฒ ะบะพัะฟัั
rus_verbs:ะฒะผะพะฝัะธัะพะฒะฐัั{}, // ะะพะฝััััะบัะพัั ะฒะผะพะฝัะธัะพะฒะฐะปะธ ะฒ ะบะพัะฟัั ะทะพะฝะดะฐ ะฝะพะฒัะต ะฟัะธะฑะพัั
rus_verbs:ะฒะผะพะฝัะธัะพะฒะฐัััั{}, // ะะพะฒัะต ะฟัะธะฑะพัั ะปะตะณะบะพ ะฒะผะพะฝัะธัะพะฒะฐะปะธัั ะฒ ะบะพัะฟัั ะทะพะฝะดะฐ
rus_verbs:ะฒะผะพัะฐะถะธะฒะฐัั{}, // ะฃััะฐะฝะพะฒะบะฐ ะฒะผะพัะฐะถะธะฒะฐะตั ัะฒะฐะธ ะฒ ะณััะฝั
rus_verbs:ะฒะผะพัะฐะถะธะฒะฐัััั{}, // ะกะฒะฐะธ ะฒะผะพัะฐะถะธะฒะฐัััั ะฒ ะณััะฝั
rus_verbs:ะฒะผะพัะพะทะธัั{}, // ะฃััะฐะฝะพะฒะบะฐ ะฒะผะพัะพะทะธะปะฐ ัะฒะฐะธ ะฒ ะณััะฝั
rus_verbs:ะฒะผััะพะฒะฐัั{}, // ะกะตะนั ะฑัะป ะฒะผััะพะฒะฐะฝ ะฒ ััะตะฝั
rus_verbs:ะฒะผััะพะฒัะฒะฐัั{}, // ะฒะผััะพะฒัะฒะฐัั ัะตะนั ะฒ ััะตะฝั
rus_verbs:ะฒะผััะพะฒัะฒะฐัััั{}, // ัะตะนั ะฒะผััะพะฒัะฒะฐะตััั ะฒ ะฑะตัะพะฝะฝัั ััะตะฝั
rus_verbs:ะฒะฝะตะดัะธัั{}, // ะฒะฝะตะดัะธัั ะธะฝะฝะพะฒะฐัะธั ะฒ ะฟัะพะธะทะฒะพะดััะฒะพ
rus_verbs:ะฒะฝะตะดัะธัััั{}, // ะจะฟะธะพะฝ ะฒะฝะตะดัะธะปัั ะฒ ััะบะพะฒะพะดััะฒะพ
rus_verbs:ะฒะฝะตะดัััั{}, // ะฒะฝะตะดัััั ะธะฝะฝะพะฒะฐัะธะธ ะฒ ะฟัะพะธะทะฒะพะดััะฒะพ
rus_verbs:ะฒะฝะตะดัััััั{}, // ะจะฟะธะพะฝั ะฒะฝะตะดัััััั ะฒ ััะบะพะฒะพะดััะฒะพ
rus_verbs:ะฒะฝะตััะธ{}, // ะฒะฝะตััะธ ะบะพัะพะฑะบั ะฒ ะดะพะผ
rus_verbs:ะฒะฝะตััะธัั{}, // ะฒะฝะตััะธัั ะฒ ัะฟะธัะพะบ ะฟัะธะณะปะฐัะตะฝะฝัั
ะณะพััะตะน
rus_verbs:ะฒะฝะธะบะฐัั{}, // ะ ะฐะทัะฐะฑะพััะธะบ ะฒะฝะธะบะฐะตั ะฒ ะดะตัะฐะปะธ ะทะฐะดะฐัะธ
rus_verbs:ะฒะฝะธะบะฝััั{}, // ะะธะทะฐะนะฝะตั ะฒะฝะธะบ ะฒ ะดะตัะฐะปะธ ะทะฐะดะฐัะธ
rus_verbs:ะฒะฝะพัะธัั{}, // ะฒะฝะพัะธัั ะฝะพะฒะพะต ะดะตะนััะฒัััะตะต ะปะธัะพ ะฒ ัะฟะธัะพะบ ะณะปะฐะฒะฝัั
ะณะตัะพะตะฒ
rus_verbs:ะฒะฝะพัะธัััั{}, // ะฒะฝะพัะธัััั ะฒ ัะฟะธัะพะบ ะณะปะฐะฒะฝัั
ะฟะตััะพะฝะฐะถะตะน
rus_verbs:ะฒะฝัั
ะฐัััั{}, // ะัั ะฒะฝัั
ะฐะปัั ะฒ ะฐัะพะผะฐัั ะปะตัะฐ
rus_verbs:ะฒะฝัั
ะธะฒะฐัััั{}, // ะัั ะฒะฝัั
ะธะฒะฐะตััั ะฒ ะฐัะพะผะฐัั ะปะตัะฐ
rus_verbs:ะฒะพะฑัะฐัั{}, // ะฒะพะฑัะฐัั ะฒ ัะตะฑั ะปัััะธะต ะผะตัะพะดั ะฑะพััะฑั ั ะฒัะตะดะธัะตะปัะผะธ
rus_verbs:ะฒะพะฒะปะตะบะฐัั{}, // ะฒะพะฒะปะตะบะฐัั ัััะดะฝัั
ะฟะพะดัะพััะบะพะฒ ะฒ ะทะฐะฝััะธะต ัะฟะพััะพะผ
rus_verbs:ะฒะพะณะฝะฐัั{}, // ะฒะพะณะฝะฐะป ัะตะปะพะฒะตะบะฐ ะฒ ัะพัะบั
rus_verbs:ะฒะพะดะฒะพัะธัั{}, // ะฒะพะดะฒะพัะธัั ะฟัะตัััะฟะฝะธะบะฐ ะฒ ััััะผั
rus_verbs:ะฒะพะทะฒะตัะฝััั{}, // ะฒะพะทะฒะตัะฝััั ะฒ ัะพะดะฝัั ััะธั
ะธั
rus_verbs:ะฒะพะทะฒะตัะฝััััั{}, // ะฒะพะทะฒะตัะฝััััั ะฒ ัะพะดะฝัั ััะธั
ะธั
rus_verbs:ะฒะพะทะฒะตััะธ{}, // ะฒะพะทะฒะตััะธ ัะธัะปะพ ะฒ ัะตัะฝัั ััะตะฟะตะฝั
rus_verbs:ะฒะพะทะฒะพะดะธัั{}, // ะฒะพะทะฒะพะดะธัั ัะธัะปะพ ะฒ ัะตัะฝัั ััะตะฟะตะฝั
rus_verbs:ะฒะพะทะฒะพะดะธัััั{}, // ัะธัะปะพ ะฒะพะทะฒะพะดะธััั ะฒ ัะตัะฝัั ััะตะฟะตะฝั
rus_verbs:ะฒะพะทะฒัะฐัะธัั{}, // ะฒะพะทะฒัะฐัะธัั ะบะพัะพะฒ ะฒ ััะพะนะปะพ
rus_verbs:ะฒะพะทะฒัะฐัะธัััั{}, // ะฒะพะทะฒัะฐัะธัััั ะฒ ัะพะดะฝะพะน ะดะพะผ
rus_verbs:ะฒะพะทะฒัะฐัะฐัั{}, // ะฒะพะทะฒัะฐัะฐัั ะบะพัะพะฒ ะฒ ััะพะนะปะพ
rus_verbs:ะฒะพะทะฒัะฐัะฐัััั{}, // ะฒะพะทะฒัะฐัะฐัััั ะฒ ัะพะดะฝะพะน ะดะพะผ
rus_verbs:ะฒะพะนัะธ{}, // ะฒะพะนัะธ ะฒ ะณะฐะปะตัะตั ัะปะฐะฒั
rus_verbs:ะฒะพะฝะทะฐัั{}, // ะะพะปั ะฒะพะฝะทะฐะตั ะฒะธะปะบั ะฒ ะบะพัะปะตัั
rus_verbs:ะฒะพะฝะทะฐัััั{}, // ะะธะปะบะฐ ะฒะพะฝะทะฐะตััั ะฒ ะบะพัะปะตัั
rus_verbs:ะฒะพะฝะทะธัั{}, // ะะพะปั ะฒะพะฝะทะธะป ะฒะธะปะบั ะฒ ะบะพัะปะตัั
rus_verbs:ะฒะพะฝะทะธัััั{}, // ะะธะปะบะฐ ะฒะพะฝะทะธะปะฐัั ะฒ ัะพัะฝัั ะบะพัะปะตัั
rus_verbs:ะฒะพะฟะปะพัะธัั{}, // ะะพะปั ะฒะพะฟะปะพัะธะป ัะฒะพะธ ะผะตััั ะฒ ัะตะฐะปัะฝะพััั
rus_verbs:ะฒะพะฟะปะพัะธัััั{}, // ะะตััั ะฒะพะฟะปะพัะธะปะธัั ะฒ ัะตะฐะปัะฝะพััั
rus_verbs:ะฒะพะฟะปะพัะฐัั{}, // ะะพะปั ะฒะพะฟะปะพัะฐะตั ะผะตััั ะฒ ัะตะฐะปัะฝะพััั
rus_verbs:ะฒะพะฟะปะพัะฐัััั{}, // ะะตััั ะธะฝะพะณะดะฐ ะฒะพะฟะปะพัะฐัััั ะฒ ัะตะฐะปัะฝะพััั
rus_verbs:ะฒะพัะฒะฐัััั{}, // ะะตัะตะผะตะฝั ะฝะตะพะถะธะดะฐะฝะฝะพ ะฒะพัะฒะฐะปะธัั ะฒ ัะฐะทะผะตัะตะฝะฝัั ะถะธะทะฝั
rus_verbs:ะฒะพัะฟะฐัะธัั{}, // ะััะฐ ะฒะพัะฟะฐัะธะปะฐ ะฒ ะฝะตะฑะพ
rus_verbs:ะฒะพัะฟะฐัััั{}, // ะััะฐ ะฒะพัะฟะฐััะตั ะฒ ะฝะตะฑะพ
rus_verbs:ะฒัััั{}, // ะฒัััั ะพะฟะพัั ะฒ ะทะตะผะปั
rus_verbs:ะฒัััััั{}, // ะฒัััััั ะฒ ะทะตะผะปั
rus_verbs:ะฒัะฐะดะธัั{}, // ะฒัะฐะดะธัั ะฟัะปั ะฒ ัะตัะดัะต
rus_verbs:ะฒัะฐะถะธะฒะฐัั{}, // ะฒัะฐะถะธะฒะฐัั ะฝะพะถ ะฒ ะฑะพะบ
rus_verbs:ะฒัะฐััะฒะฐัั{}, // ะฒัะฐััะฒะฐัั ะฒะพะดั ะฒ ัะตะฑั
rus_verbs:ะฒัะฐััะฒะฐัััั{}, // ะฒัะฐััะฒะฐัััั ะฒ ัะผะบะพััั
rus_verbs:ะฒัะตะปะธัั{}, // ะฒัะตะปะธัั ะฝะฐะดะตะถะดั ะฒ ะบะพะณะพ-ะปะธะฑะพ
rus_verbs:ะฒัะตะปะธัััั{}, // ะฒัะตะปะธัััั ะฒ ะฟััััััะตะต ะทะดะฐะฝะธะต
rus_verbs:ะฒัะตะปััั{}, // ะฒัะตะปััั ะฝะฐะดะตะถะดั ะฒ ะบะพะณะพ-ัะพ
rus_verbs:ะฒัะตะปััััั{}, // ะฒัะตะปััััั ะฒ ะฟััััััะตะต ะทะดะฐะฝะธะต
rus_verbs:ะฒัะบะธะดัะฒะฐัั{}, // ะฒัะบะธะดัะฒะฐัั ััะบั ะฒ ะฝะตะฑะพ
rus_verbs:ะฒัะบะธะฝััั{}, // ะฒัะบะธะฝััั ััะบั ะฒ ะฝะตะฑะพ
rus_verbs:ะฒัะปััะฐัััั{}, // ะฒัะปััะฐัััั ะฒ ะทะฒัะบะธ
rus_verbs:ะฒัะปััะธะฒะฐัััั{}, // ะฒัะปััะธะฒะฐัััั ะฒ ัะพัะพั
rus_verbs:ะฒัะผะฐััะธะฒะฐัััั{}, // ะฒัะผะฐััะธะฒะฐัััั ะฒ ัะตะผะฝะพัั
rus_verbs:ะฒัะผะพััะตัััั{}, // ะฒัะผะพััะตัััั ะฒ ัะตะผะตะฝั
rus_verbs:ะฒัะพะฒัะฒะฐัั{}, // ะฒัะพะฒัะฒะฐัั ะฟะฐะปะตั ะฒ ะพัะฒะตัััะธะต
rus_verbs:ะฒัะพะฒัะฒะฐัััั{}, // ะฒัะพะฒัะฒะฐัััั ะฒ ัะพััะพัะบั
rus_verbs:ะฒัะพัะฐัั{}, // ะฒัะพัะฐัั ะถะธะดะบะพััั ะฒ ัะตะฑั
rus_verbs:ะฒัะพัะฐัััั{}, // ะฒัะพัะฐัััั ะฒ ะบะพะถั
rus_verbs:ะฒััะฐะฒะธัั{}, // ะฒััะฐะฒะธัั ะบะปัั ะฒ ะทะฐะผะพะบ
rus_verbs:ะฒััะฐะฒะปััั{}, // ะฒััะฐะฒะปััั ะบะปัั ะฒ ะทะฐะผะพะบ
rus_verbs:ะฒัััะฐะธะฒะฐัั{}, // ะฒัััะฐะธะฒะฐัั ัะตัะฝัะน ั
ะพะด ะฒ ัะธััะตะผั ะทะฐัะธัั
rus_verbs:ะฒัััะฐะธะฒะฐัััั{}, // ะฒัััะฐะธะฒะฐัััั ะฒ ัะธััะตะผั ะฑะตะทะพะฟะฐัะฝะพััะธ
rus_verbs:ะฒัััะตะฒะฐัั{}, // ะฒัััะตะฒะฐัั ะฒ ัะฐะทะณะพะฒะพั
rus_verbs:ะฒัััะพะธัั{}, // ะฒัััะพะธัั ัะตะบัะตัะฝัะน ะผะพะดัะปั ะฒ ัะธััะตะผั ะฑะตะทะพะฟะฐัะฝะพััะธ
rus_verbs:ะฒัััะพะธัััั{}, // ะฒัััะพะธัััั ะฒ ัะธััะตะผั ะฑะตะทะพะฟะฐัะฝะพััะธ
rus_verbs:ะฒัััััั{}, // ะฒัััััั ะฒ ัะฐะทะณะพะฒะพั
rus_verbs:ะฒัััะฟะฐัั{}, // ะฒัััะฟะฐัั ะฒ ะดะตะนััะฒััััั ะฐัะผะธั
rus_verbs:ะฒัััะฟะธัั{}, // ะฒัััะฟะธัั ะฒ ะดะตะนััะฒััััั ะฐัะผะธั
rus_verbs:ะฒััะฝััั{}, // ะฒััะฝััั ะฟะฐะปะตั ะฒ ะพัะฒะตัััะธะต
rus_verbs:ะฒััะฝััััั{}, // ะฒััะฝััััั ะฒ ัะพััะพัะบั
ะธะฝัะธะฝะธัะธะฒ:ะฒััะฟะฐัั{ะฒะธะด:ัะพะฒะตัั}, // ะฒััะฟะฐัั ะฟะพัะพัะพะบ ะฒ ะบะพะฝัะตะนะฝะตั
ะธะฝัะธะฝะธัะธะฒ:ะฒััะฟะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฒััะฟะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฒััะฟะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ะฒััะฟะฐะฒ{},
ะดะตะตะฟัะธัะฐััะธะต:ะฒััะฟะฐั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒััะฟะฐะฒัะธะน{ ะฒะธะด:ัะพะฒะตัั },
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒััะฟะฐะฒัะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒััะฟะฐะฝะฝัะน{},
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒััะฟะฐััะธะน{},
ะธะฝัะธะฝะธัะธะฒ:ะฒััะฟะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะฒััะฟะฐัััั ะฒ ะบะพะฝัะตะนะฝะตั
// ะธะฝัะธะฝะธัะธะฒ:ะฒััะฟะฐัััั{ ะฒะธะด:ัะพะฒะตัั},
// ะณะปะฐะณะพะป:ะฒััะฟะฐัััั{ ะฒะธะด:ัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฒััะฟะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั},
// ะดะตะตะฟัะธัะฐััะธะต:ะฒััะฟะฐะฒัะธัั{},
ะดะตะตะฟัะธัะฐััะธะต:ะฒััะฟะฐััั{},
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒััะฟะฐะฒัะธะนัั{ ะฒะธะด:ัะพะฒะตัั },
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒััะฟะฐะฒัะธะนัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒััะฟะฐััะธะนัั{},
rus_verbs:ะฒัะฐะปะบะธะฒะฐัั{}, // ะฒัะฐะปะบะธะฒะฐัั ะดะตัะฐะปั ะฒ ััะตะนะบั
rus_verbs:ะฒัะฐะปะบะธะฒะฐัััั{}, // ะฒัะฐะปะบะธะฒะฐัััั ะฒ ััะตะนะบั
rus_verbs:ะฒัะฐะฟััะฒะฐัั{}, // ะฒัะฐะฟััะฒะฐัั ะฒ ะณััะทั
rus_verbs:ะฒัะฐะฟััะฒะฐัััั{}, // ะฒัะฐะฟััะฒะฐัััั ะฒ ะณััะทั
rus_verbs:ะฒัะฐัะบะธะฒะฐัั{}, // ะฒัะฐัะบะธะฒะฐัั ะผะตัะพะบ ะฒ ะบะพะผะฝะฐัั
rus_verbs:ะฒัะฐัะบะธะฒะฐัััั{}, // ะฒัะฐัะบะธะฒะฐัััั ะฒ ะบะพะผะฝะฐัั
rus_verbs:ะฒัะฐัะธัั{}, // ะฒัะฐัะธัั ะผะตัะพะบ ะฒ ะบะพะผะฝะฐัั
rus_verbs:ะฒัะฐัะธัััั{}, // ะฒัะฐัะธัััั ะฒ ะบะพะผะฝะฐัั
rus_verbs:ะฒัะตะบะฐัั{}, // ะฒัะตะบะฐัั ะฒ ะฑัััะปะบั
rus_verbs:ะฒัะตะผััะธะฒะฐัั{}, // ะฒัะตะผััะธะฒะฐัั ะฒ ะณะพะปะพะฒั
rus_verbs:ะฒัะตะผััะธะฒะฐัััั{}, // ะฒัะตะผััะธะฒะฐัััั ะฒ ะณะพะปะพะฒั
rus_verbs:ะฒัะตะผััะธัั{}, // ะฒัะตะผััะธัั ะฒ ะณะพะปะพะฒั
rus_verbs:ะฒัะตะผััะธัััั{}, // ะฒัะตะผััะธัััั ะฒ ะณะพะปะพะฒั
rus_verbs:ะฒัะตัะตัั{}, // ะฒัะตัะตัั ะบัะตะผ ะฒ ะบะพะถั
rus_verbs:ะฒัะตัะตัััั{}, // ะฒัะตัะตัััั ะฒ ะบะพะถั
rus_verbs:ะฒัะตัะฐัััั{}, // ะฒัะตัะฐัััั ะฒ ะณััะฟะฟั
rus_verbs:ะฒัะตััะฒะฐัั{}, // ะฒัะตััะฒะฐัั ะฒ ะณััะฟะฟั
rus_verbs:ะฒัะตััะฒะฐัััั{}, // ะฒัะตััะฒะฐัััั ะฒ ะณััะฟะฟั
rus_verbs:ะฒัะตัั{}, // ะฒัะตัั ะฒ ะฑะฐะบ
rus_verbs:ะฒัะธัะฐัั{}, // ะฒัะธัะฐัั ะบัะตะผ ะฒ ะบะพะถั
rus_verbs:ะฒัะธัะฐัััั{}, // ะฒัะธัะฐัััั ะฒ ะบะพะถั
rus_verbs:ะฒัะธัะบะธะฒะฐัั{}, // ะฒัะธัะบะธะฒะฐัั ััะผะบั ะฒ ะฒะฐะณะพะฝ
rus_verbs:ะฒัะธัะบะธะฒะฐัััั{}, // ะฒัะธัะบะธะฒะฐัััั ะฒ ะฟะตัะตะฟะพะปะฝะตะฝะฝัะน ะฒะฐะณะพะฝ
rus_verbs:ะฒัะธัะฝััั{}, // ะฒัะธัะฝััั ััะผะบั ะฒ ะฒะฐะณะพะฝ
rus_verbs:ะฒัะธัะฝััััั{}, // ะฒัะธัะฝััััั ะฒ ะฟะตัะตะฟะพะปะฝะตะฝะฝัะน ะฒะฐะณะพะฝ ะผะตััะพ
rus_verbs:ะฒัะพะปะบะฐัั{}, // ะฒัะพะปะบะฐัั ะบะพะปััะบั ะฒ ะปะธัั
rus_verbs:ะฒัะพะปะบะฐัััั{}, // ะฒัะพะปะบะฐัััั ะฒ ะฒะฐะณะพะฝ ะผะตััะพ
rus_verbs:ะฒัะพะปะบะฝััั{}, // ะฒัะพะปะบะฝััั ะบะพะปััะบั ะฒ ะปะธัั
rus_verbs:ะฒัะพะปะบะฝััััั{}, // ะฒัะพะปะบะฝััััั ะฒ ะฒะฐะณะพะฝ ะผะตััะพ
rus_verbs:ะฒัะพะปะพัั{}, // ะฒัะพะปะพัั ะฒ ัะผะตัั
rus_verbs:ะฒัะพะฟัะฐัั{}, // ะฒัะพะฟัะฐัั ัะฒะตัั ะฒ ะทะตะผะปั
rus_verbs:ะฒัะพัะณะฐัััั{}, // ะฒัะพัะณะฐัััั ะฒ ััะถัั ะทะพะฝั
rus_verbs:ะฒัะพัะณะฝััััั{}, // ะฒัะพัะณะฝััััั ะฒ ัะฐััะฝัั ะถะธะทะฝั
rus_verbs:ะฒััะฐะฒะธัั{}, // ะฒััะฐะฒะธัั ะบะพะณะพ-ัะพ ะฒ ะฝะตะฟัะธััะฝะพััะธ
rus_verbs:ะฒััะฐะฒะปะธะฒะฐัั{}, // ะฒััะฐะฒะปะธะฒะฐัั ะบะพะณะพ-ัะพ ะฒ ะฝะตะฟัะธััะฝะพััะธ
rus_verbs:ะฒััะฐะผะฑะพะฒะฐัั{}, // ะฒััะฐะผะฑะพะฒะฐัั ะบะฐะผะฝะธ ะฒ ะทะตะผะปั
rus_verbs:ะฒััะฐะผะฑะพะฒัะฒะฐัั{}, // ะฒััะฐะผะฑะพะฒัะฒะฐัั ะบะฐะผะฝะธ ะฒ ะทะตะผะปั
rus_verbs:ะฒััะฐะผะฑะพะฒัะฒะฐัััั{}, // ะฒััะฐะผะฑะพะฒัะฒะฐัััั ะฒ ะทะตะผะปั
rus_verbs:ะฒััะตัะบะฐัััั{}, // ะฒััะตัะบะฐัััั ะฒ ะบะพะณะพ-ัะพ
rus_verbs:ะฒััะตัะบะธะฒะฐัััั{}, // ะฒััะตัะบะธะฒะฐัััั ะฒ ะบะพะณะพ-ะปะธะฑะพ
rus_verbs:ะฒััะบะฐัั{}, // ะฒััะบะฐัั ะฒะธะปะบั ะฒ ะบะพัะปะตัะบั
rus_verbs:ะฒััะบะฐัััั{}, // ะฒััะบะฐัััั ะฒ ัะพะทะตัะบั
rus_verbs:ะฒัััะธะฒะฐัััั{}, // ะฒัััะธะฒะฐัััั ะฒ ะบะพะณะพ-ะปะธะฑะพ
rus_verbs:ะฒัััะธัััั{}, // ะฒัััะธัััั ะฒ ะบะพะณะพ-ะปะธะฑะพ
rus_verbs:ะฒััะณะธะฒะฐัั{}, // ะฒััะณะธะฒะฐัั ััะพ-ัะพ ะฒ ัะตะฑั
rus_verbs:ะฒััะณะธะฒะฐัััั{}, // ะฒััะณะธะฒะฐัััั ะฒ ัะตะฑั
rus_verbs:ะฒััะฝััััั{}, // ะฒััะฝััััั ะฒ ัะตะฑั
rus_verbs:ะฒัะตะผะตะฝัะธัะพะฒะฐัั{}, // ะฒัะตะผะตะฝัะธัะพะฒะฐัั ัะฒะฐั ะฒ ััะฝะดะฐะผะตะฝั
rus_verbs:ะฒัะตะบะฐะฝะธัั{}, // ะฒัะตะบะฐะฝะธัั ะฝะฐะดะฟะธัั ะฒ ะปะธัั
rus_verbs:ะฒัะธัะฐัััั{}, // ะฒัะธัะฐัััั ะฒะฝะธะผะฐัะตะปัะฝะตะต ะฒ ัะตะบัั
rus_verbs:ะฒัะธััะฒะฐัััั{}, // ะฒัะธััะฒะฐัััั ะฒะฝะธะผะฐัะตะปัะฝะตะต ะฒ ัะตะบัั
rus_verbs:ะฒััะฒััะฒะพะฒะฐัััั{}, // ะฒััะฒััะฒะพะฒะฐัััั ะฒ ัะพะปั
rus_verbs:ะฒัะฐะณะธะฒะฐัั{}, // ะฒัะฐะณะธะฒะฐัั ะฒ ะฝะพะฒัั ะถะธะทะฝั
rus_verbs:ะฒัะฐะณะฝััั{}, // ะฒัะฐะณะฝััั ะฒ ะฝะพะฒัั ะถะธะทะฝั
rus_verbs:ะฒัะธะฒะฐัั{}, // ะฒัะธะฒะฐัั ะทะฐะฟะปะฐัั ะฒ ััะฑะฐัะบั
rus_verbs:ะฒัะธะฒะฐัััั{}, // ะฒัะธะฒะฐัััั ะฒ ัะบะฐะฝั
rus_verbs:ะฒัะธัั{}, // ะฒัะธัั ะทะฐะฟะปะฐัั ะฒ ัะบะฐะฝั
rus_verbs:ะฒัะตะดะฐัััั{}, // ะฒัะตะดะฐัััั ะฒ ะผัะบะพัั
rus_verbs:ะฒัะตะทะถะฐัั{}, // ะฒัะตะทะถะฐัั ะฒ ะณะฐัะฐะถ
rus_verbs:ะฒัะตั
ะฐัั{}, // ะฒัะตั
ะฐัั ะฒ ะณะฐัะฐะถ
rus_verbs:ะฒัะธะณัะฐัั{}, // ะะพะปั ะฒัะธะณัะฐะป ะฒ ัะฐั
ะผะฐัั
rus_verbs:ะฒัะธะณััะฒะฐัั{}, // ะะพะปั ัะฐััะพ ะฒัะธะณััะฒะฐะตั ั ะผะตะฝั ะฒ ัะฐั
ะผะฐัั
rus_verbs:ะฒัะบะปะฐะดัะฒะฐัั{}, // ะฒัะบะปะฐะดัะฒะฐัั ะฒ ะพะฑัะธะน ะดะพัััะฟ
rus_verbs:ะฒัะบะปะฐะดัะฒะฐัััั{}, // ะฒัะบะปะฐะดัะฒะฐัััั ะฒ ะพะฑัะธะน ะดะพัััะฟ
rus_verbs:ะฒัะบัะฐัะธัั{}, // ะฒัะบัะฐัะธัั ะผะฐัะธะฝั ะฒ ัะพะทะพะฒัะน ัะฒะตั
rus_verbs:ะฒัะบัะฐัะธัััั{}, // ะฒัะบัะฐัะธัััั ะฒ ะดะตัะทะบะธะน ัะพะทะพะฒัะน ัะฒะตั
rus_verbs:ะฒัะบัะฐัะธะฒะฐัั{}, // ะฒัะบัะฐัะธะฒะฐัั ะฒะพะปะพัั ะฒ ะบัะฐัะฝัะน ัะฒะตั
rus_verbs:ะฒัะบัะฐัะธะฒะฐัััั{}, // ะฒัะบัะฐัะธะฒะฐัััั ะฒ ะบัะฐัะฝัะน ัะฒะตั
rus_verbs:ะฒัะปะตะทะฐัั{}, // ะฒัะปะตะทะฐัั ะฒ ะพัะบัััะพะต ะฟัะพัััะฐะฝััะฒะพ
rus_verbs:ะฒัะปะตะทัะธ{}, // ะฒัะปะตะทัะธ ะฒ ะพัะบัััะพะต ะฟัะพัััะฐะฝััะฒะพ
rus_verbs:ะฒัะปะธะฒะฐัั{}, // ะฒัะปะธะฒะฐัั ะฒ ะฑัััะปะบั
rus_verbs:ะฒัะปะธะฒะฐัััั{}, // ะฒัะปะธะฒะฐัััั ะฒ ัะผะบะพััั
rus_verbs:ะฒัะปะธัั{}, // ะฒัะปะธัั ะพัั
ะพะดั ะฒ ะบะฐะฝะฐะปะธะทะฐัะธั
rus_verbs:ะฒัะปะธัััั{}, // ะขะพะฟะปะธะฒะพ ะฒัะปะธะปะพัั ะฒ ะฒะพะดั
rus_verbs:ะฒัะปะพะถะธัั{}, // ะฒัะปะพะถะธัั ะฒ ะพะฑัะธะน ะดะพัััะฟ
rus_verbs:ะฒัะฟะฐะดะฐัั{}, // ะฒัะฟะฐะดะฐัั ะฒ ะพัะฐะดะพะบ
rus_verbs:ะฒัะฟััะณะธะฒะฐัั{}, // ะฒัะฟััะณะธะฒะฐัั ะฒ ะพะบะฝะพ
rus_verbs:ะฒัะฟััะณะฝััั{}, // ะฒัะฟััะณะฝััั ะฒ ะพะบะฝะพ
rus_verbs:ะฒััะพะดะธัััั{}, // ะฒััะพะดะธัััั ะฒ ะถะฐะปะบะพะต ะฟะพะดะพะฑะธะต
rus_verbs:ะฒััะพะถะดะฐัััั{}, // ะฒััะพะถะดะฐัััั ะฒ ะถะฐะปะบะพะต ะฟะพะดะพะฑะธะต ัะปะฐะฒะฝัั
ะฟัะตะดะบะพะฒ
rus_verbs:ะฒััะตะฒะฐัััั{}, // ะฒััะตะฒะฐัััั ะฒ ะทะตะผะปั
rus_verbs:ะฒััะตััั{}, // ะฒััะตััั ะฒ ะทะตะผะปั
rus_verbs:ะฒััะปะฐัั{}, // ะฒััะปะฐัั ะฒ ัััะฐะฝั ะฟะพััะพัะฝะฝะพะณะพ ะฟัะตะฑัะฒะฐะฝะธั
rus_verbs:ะฒััะผะพัะบะฐัััั{}, // ะฒััะผะพัะบะฐัััั ะฒ ะฟะปะฐัะพะบ
rus_verbs:ะฒััะผะพัะบะฝััััั{}, // ะฒััะผะพัะบะฝััััั ะฒ ะฟะปะฐัะพะบ
rus_verbs:ะฒััััะตะปะธะฒะฐัั{}, // ะฒััััะตะปะธะฒะฐัั ะฒ ัะตะปั
rus_verbs:ะฒััััะตะปะธะฒะฐัััั{}, // ะฒััััะตะปะธะฒะฐัััั ะฒ ัะตะปั
rus_verbs:ะฒััััะตะปะธัั{}, // ะฒััััะตะปะธัั ะฒ ัะตะปั
rus_verbs:ะฒััะตะบะฐัั{}, // ะฒััะตะบะฐัั ะฒ ะพะทะตัะพ
rus_verbs:ะฒััะตัั{}, // ะฒััะตัั ะฒ ะฒะพะดั
rus_verbs:ัะผะพััะตัั{}, // ัะผะพััะตัั ะฒ ะฑัะดััะตะต
rus_verbs:ะฟะพะดะฝััััั{}, // ะฟะพะดะฝััััั ะฒ ะปะฐะฑะพัะฐัะพัะธั
rus_verbs:ะฟะพัะปะฐัั{}, // ะฟะพัะปะฐัั ะฒ ะผะฐะณะฐะทะธะฝ
rus_verbs:ัะปะฐัั{}, // ัะปะฐัั ะฒ ะฝะตะธะทะฒะตััะฝะพััั
rus_verbs:ะดะพะฑะฐะฒะธัั{}, // ะดะพะฑะฐะฒะธัั ะฒ ััะฟ
rus_verbs:ะฟัะพะนัะธ{}, // ะฟัะพะนัะธ ะฒ ะปะฐะฑะพัะฐัะพัะธั
rus_verbs:ะฟะพะปะพะถะธัั{}, // ะฟะพะปะพะถะธัั ะฒ ััะธะบ
rus_verbs:ะฟัะธัะปะฐัั{}, // ะฟัะธัะปะฐัั ะฒ ะฟะพะปะธัะธั
rus_verbs:ัะฟะฐััั{}, // ัะฟะฐััั ะฒ ะฟัะพะฟะฐััั
ะธะฝัะธะฝะธัะธะฒ:ะฟะธัะฐัั{ aux stress="ะฟะธั^ะฐัั" }, // ะฟะธัะฐัั ะฒ ะณะฐะทะตัั
ะธะฝัะธะฝะธัะธะฒ:ะฟะธัะฐัั{ aux stress="ะฟ^ะธัะฐัั" }, // ะฟะธัะฐัั ะฒ ััะฐะฝะธัะบะธ
ะณะปะฐะณะพะป:ะฟะธัะฐัั{ aux stress="ะฟ^ะธัะฐัั" },
ะณะปะฐะณะพะป:ะฟะธัะฐัั{ aux stress="ะฟะธั^ะฐัั" },
ะดะตะตะฟัะธัะฐััะธะต:ะฟะธัะฐั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะธัะฐะฒัะธะน{ aux stress="ะฟ^ะธัะฐะฒัะธะน" }, // ะฟะธัะฐะฒัะธะน ะฒ ััะฐะฝะธัะบะธ
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะธัะฐะฒัะธะน{ aux stress="ะฟะธั^ะฐะฒัะธะน" }, // ะฟะธัะฐะฒัะธะน ะฒ ะณะฐะทะตัั
rus_verbs:ัะพะฑะธัะฐัััั{}, // ัะพะฑะธัะฐัััั ะฒ ะฟะพั
ะพะด
rus_verbs:ะทะฒะฐัั{}, // ะทะฒะฐัั ะฒ ัะตััะพัะฐะฝ
rus_verbs:ะฝะฐะฟัะฐะฒะธัััั{}, // ะฝะฐะฟัะฐะฒะธัััั ะฒ ัะตััะพัะฐะฝ
rus_verbs:ะพัะฟัะฐะฒะธัััั{}, // ะพัะฟัะฐะฒะธัััั ะฒ ัะตััะพัะฐะฝ
rus_verbs:ะฟะพััะฐะฒะธัั{}, // ะฟะพััะฐะฒะธัั ะฒ ัะณะพะป
rus_verbs:ัะตะปะธัั{}, // ัะตะปะธัั ะฒ ะผะธัะตะฝั
rus_verbs:ะฟะพะฟะฐััั{}, // ะฟะพะฟะฐััั ะฒ ะฟะตัะตะฟะปะตั
rus_verbs:ัะดะฐัะธัั{}, // ัะดะฐัะธัั ะฒ ะฑะพะปัะฝะพะต ะผะตััะพ
rus_verbs:ะทะฐะบัะธัะฐัั{}, // ะทะฐะบัะธัะฐัั ะฒ ะผะธะบัะพัะพะฝ
rus_verbs:ะพะฟัััะธัั{}, // ะพะฟัััะธัั ะฒ ะฒะพะดั
rus_verbs:ะฟัะธะฝะตััะธ{}, // ะฟัะธะฝะตััะธ ะฒ ะดะพะผ ะฑะตะทะดะพะผะฝะพะณะพ ัะตะฝะบะฐ
rus_verbs:ะพัะดะฐัั{}, // ะพัะดะฐัั ะฒ ั
ะพัะพัะธะต ััะบะธ
rus_verbs:ั
ะพะดะธัั{}, // ั
ะพะดะธัั ะฒ ัะบะพะปั
rus_verbs:ัััะฐะฒะธัััั{}, // ัััะฐะฒะธัััั ะฒ ัะบัะฐะฝ
rus_verbs:ะฟัะธั
ะพะดะธัั{}, // ะฟัะธั
ะพะดะธัั ะฒ ะฑะตัะตะฝััะฒะพ
rus_verbs:ะผะฐั
ะฝััั{}, // ะผะฐั
ะฝััั ะฒ ะัะฐะปะธั
rus_verbs:ััะฝััั{}, // ััะฝััั ะฒ ะทะฐะผะพัะฝัั ัะบะฒะฐะถะธะฝั
rus_verbs:ัะฒะธัััั{}, // ัะฒะธัััั ะฒ ัะฐัะฟะพะปะพะถะตะฝะธะต ัะฐััะธ
rus_verbs:ัะตั
ะฐัั{}, // ัะตั
ะฐัั ะฒ ะณะพัะพะด
rus_verbs:ัะตะปะพะฒะฐัั{}, // ัะตะปะพะฒะฐัั ะฒ ะปะพะฑะธะบ
rus_verbs:ะฟะพะฒะตััะธ{}, // ะฟะพะฒะตััะธ ะฒ ะฑะพะน
rus_verbs:ะพะฟัััะธัััั{}, // ะพะฟัััะธัััั ะฒ ะบัะตัะปะพ
rus_verbs:ะฟะตัะตะดะฐัั{}, // ะฟะตัะตะดะฐัั ะฒ ะฐัั
ะธะฒ
rus_verbs:ะฟะพะฑะตะถะฐัั{}, // ะฟะพะฑะตะถะฐัั ะฒ ัะบะพะปั
rus_verbs:ััะตัั{}, // ััะตัั ะฒ ะฒะพะดั
rus_verbs:ัั
ะพะดะธัั{}, // ัั
ะพะดะธัั ะดะพะฑัะพะฒะพะปััะตะผ ะฒ ะฐัะผะธั
rus_verbs:ะฟัะธะฒะตััะธ{}, // ะฟัะธะฒะตััะธ ะฒ ะดะพะผ
rus_verbs:ัะฐะณะฝััั{}, // ัะฐะณะฝััั ะฒ ะฝะตะธะทะฒะตััะฝะพััั
rus_verbs:ัะพะฑัะฐัััั{}, // ัะพะฑัะฐัััั ะฒ ะฟะพั
ะพะด
rus_verbs:ะทะฐะณะปัะฝััั{}, // ะทะฐะณะปัะฝััั ะฒ ะพัะฝะพะฒั
rus_verbs:ะฟะพัะฟะตัะธัั{}, // ะฟะพัะฟะตัะธัั ะฒ ัะตัะบะพะฒั
rus_verbs:ะฟะพัะตะปะพะฒะฐัั{}, // ะฟะพัะตะปะพะฒะฐัั ะฒ ะปะพะฑ
rus_verbs:ะฟะตัะตะนัะธ{}, // ะฟะตัะตะนัะธ ะฒ ะฒััััั ะปะธะณั
rus_verbs:ะฟะพะฒะตัะธัั{}, // ะฟะพะฒะตัะธัั ะฒ ะธัะบัะตะฝะฝะพััั
rus_verbs:ะณะปัะฝััั{}, // ะณะปัะฝััั ะฒ ะพะณะปะฐะฒะปะตะฝะธะต
rus_verbs:ะทะฐะนัะธ{}, // ะทะฐะนัะธ ะฒ ะบะฐัะตัะตัะธะน
rus_verbs:ะฟะพะดะพะฑัะฐัั{}, // ะฟะพะดะพะฑัะฐัั ะฒ ะปะตัั
rus_verbs:ะฟัะพั
ะพะดะธัั{}, // ะฟัะพั
ะพะดะธัั ะฒ ะฟะพะผะตัะตะฝะธะต
rus_verbs:ะณะปัะดะตัั{}, // ะณะปัะดะตัั ะฒ ะณะปะฐะทะฐ
rus_verbs:ะฟัะธะณะปะฐัะธัั{}, // ะฟัะธะณะปะฐัะธัั ะฒ ัะตะฐัั
rus_verbs:ะฟะพะทะฒะฐัั{}, // ะฟะพะทะฒะฐัั ะฒ ะบะปะฐัั
rus_verbs:ััะตััััั{}, // ััะตััััั ะฒ ะบัะตัะปะพ
rus_verbs:ะฟะพัััะฟะธัั{}, // ะฟะพัััะฟะธัั ะฒ ะธะฝััะธััั
rus_verbs:ะปะตัั{}, // ะปะตัั ะฒ ะฟะพััะตะปั
rus_verbs:ะฟะพะบะปะพะฝะธัััั{}, // ะฟะพะบะปะพะฝะธัััั ะฒ ะฟะพัั
rus_verbs:ะฟะพััะฝััััั{}, // ะฟะพััะฝััััั ะฒ ะปะตั
rus_verbs:ะบะพะปะพัั{}, // ะบะพะปะพัั ะฒ ัะณะพะดะธัั
rus_verbs:ะฟัะธัะตััั{}, // ะฟัะธัะตััั ะฒ ะบัะตัะปะพ
rus_verbs:ะพะณะปัะดะตัััั{}, // ะพะณะปัะดะตัััั ะฒ ะทะตัะบะฐะปะพ
rus_verbs:ะฟะพะณะปัะดะตัั{}, // ะฟะพะณะปัะดะตัั ะฒ ะทะตัะบะฐะปะพ
rus_verbs:ะฟัะตะฒัะฐัะธัััั{}, // ะฟัะตะฒัะฐัะธัััั ะฒ ะปัะณััะบั
rus_verbs:ะฟัะธะฝะธะผะฐัั{}, // ะฟัะธะฝะธะผะฐัั ะฒะพ ะฒะฝะธะผะฐะฝะธะต
rus_verbs:ะทะฒะพะฝะธัั{}, // ะทะฒะพะฝะธัั ะฒ ะบะพะปะพะบะพะปะฐ
rus_verbs:ะฟัะธะฒะตะทัะธ{}, // ะฟัะธะฒะตะทัะธ ะฒ ะณะพััะธะฝะธัั
rus_verbs:ััั
ะฝััั{}, // ััั
ะฝััั ะฒ ะฟัะพะฟะฐััั
rus_verbs:ะฟััะบะฐัั{}, // ะฟััะบะฐัั ะฒ ะดะตะปะพ
rus_verbs:ะพัะฒะตััะธ{}, // ะพัะฒะตััะธ ะฒ ะฑะพะปัะฝะธัั
rus_verbs:ัะพะนัะธ{}, // ัะพะนัะธ ะฒ ะฐะด
rus_verbs:ะฝะฐะฑัะฐัั{}, // ะฝะฐะฑัะฐัั ะฒ ะบะพะผะฐะฝะดั
rus_verbs:ัะพะฑัะฐัั{}, // ัะพะฑัะฐัั ะฒ ะบัะปะฐะบ
rus_verbs:ะดะฒะธะณะฐัััั{}, // ะดะฒะธะณะฐัััั ะฒ ะบะฐััั
rus_verbs:ะฟะฐะดะฐัั{}, // ะฟะฐะดะฐัั ะฒ ะพะฑะปะฐััั ะฝัะปั
rus_verbs:ะฟะพะปะตะทัั{}, // ะฟะพะปะตะทัั ะฒ ะดัะฐะบั
rus_verbs:ะฝะฐะฟัะฐะฒะธัั{}, // ะฝะฐะฟัะฐะฒะธัั ะฒ ััะฐัะธะพะฝะฐั
rus_verbs:ะฟัะธะฒะพะดะธัั{}, // ะฟัะธะฒะพะดะธัั ะฒ ััะฒััะฒะพ
rus_verbs:ัะพะปะบะฝััั{}, // ัะพะปะบะฝััั ะฒ ะฑะพะบ
rus_verbs:ะบะธะฝััััั{}, // ะบะธะฝััััั ะฒ ะดัะฐะบั
rus_verbs:ัะบะฝััั{}, // ัะบะฝััั ะฒ ะณะปะฐะท
rus_verbs:ะทะฐะบะปััะธัั{}, // ะทะฐะบะปััะธัั ะฒ ะพะฑัััะธั
rus_verbs:ะฟะพะดะฝะธะผะฐัััั{}, // ะฟะพะดะฝะธะผะฐัััั ะฒ ะฝะตะฑะพ
rus_verbs:ัะฐััะธ{}, // ัะฐััะธ ะฒ ะณะปัะฑะธะฝั
rus_verbs:ะฝะฐะปะธัั{}, // ะฝะฐะปะธัั ะฒ ะบััะถะบั
rus_verbs:ัะฒััะฝััั{}, // ัะฒััะฝััั ะฒ ะฑะตะทะดะฝั
rus_verbs:ะฟััะณะฝััั{}, // ะฟััะณะฝััั ะฒ ะดะฒะตัั
rus_verbs:ะฟัะพะผะพะปัะฐัั{}, // ะฟัะพะผะพะปัะฐัั ะฒ ัััะฟะพัะบั
rus_verbs:ัะฐะดะธัััั{}, // ัะฐะดะธัััั ะฒ ะบัะตัะปะพ
rus_verbs:ะปะธัั{}, // ะปะธัั ะฒ ะบัะฒัะธะฝ
rus_verbs:ะดะพัะปะฐัั{}, // ะดะพัะปะฐัั ะดะตัะฐะปั ะฒ ะดะตัะถะฐัะตะปั
rus_verbs:ะฟะตัะตัะปะฐัั{}, // ะฟะตัะตัะปะฐัั ะฒ ะพะฑัะฐะฑะพััะธะบ
rus_verbs:ัะดะฐะปะธัััั{}, // ัะดะฐะปะธัััั ะฒ ัะพะฒะตัะฐัะตะปัะฝัั ะบะพะผะฝะฐัั
rus_verbs:ัะฐะทะณะปัะดัะฒะฐัั{}, // ัะฐะทะณะปัะดัะฒะฐัั ะฒ ะฑะธะฝะพะบะปั
rus_verbs:ะฟะพะฒะตัะธัั{}, // ะฟะพะฒะตัะธัั ะฒ ัะบะฐั
ะธะฝัะธะฝะธัะธะฒ:ะฟะพั
ะพะดะธัั{ ะฒะธะด:ัะพะฒะตัั }, // ะฟะพั
ะพะดะธัั ะฒ ะธะฝััะธััั
ะณะปะฐะณะพะป:ะฟะพั
ะพะดะธัั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะฟะพั
ะพะดะธะฒ{},
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะพั
ะพะดะธะฒัะธะน{ะฒะธะด:ัะพะฒะตัั},
rus_verbs:ะฟะพะผัะฐัััั{}, // ะฟะพะผัะฐัััั ะฒ ะบะปะฐัั
rus_verbs:ัะฒะฐะปะธัััั{}, // ัะฒะฐะปะธัััั ะฒ ัะผั
rus_verbs:ัะฑะตะถะฐัั{}, // ัะฑะตะถะฐัั ะฒ ะะฝะณะปะธั
rus_verbs:ัััะตะปััั{}, // ัััะตะปััั ะฒ ัะตะปั
rus_verbs:ะพะฑัะฐัะฐัั{}, // ะพะฑัะฐัะฐัั ะฒ ัะฒะพั ะฒะตัั
rus_verbs:ะทะฐะฒะตััะธ{}, // ะทะฐะฒะตััะธ ะฒ ะดะพะผ
rus_verbs:ะฟัะธะพะฑัะตััะธ{}, // ะฟัะธะพะฑัะตััะธ ะฒ ัะฐัััะพัะบั
rus_verbs:ัะฑัะพัะธัั{}, // ัะฑัะพัะธัั ะฒ ัะผั
rus_verbs:ััััะพะธัััั{}, // ััััะพะธัััั ะฒ ะบััะฟะฝัั ะบะพัะฟะพัะฐัะธั
rus_verbs:ะฟะพะณััะทะธัััั{}, // ะฟะพะณััะทะธัััั ะฒ ะฟััะธะฝั
rus_verbs:ัะตัั{}, // ัะตัั ะฒ ะบะฐะฝะฐะฒั
rus_verbs:ะฟัะพะธะทะฒะตััะธ{}, // ะฟัะพะธะทะฒะตััะธ ะฒ ะทะฒะฐะฝะธะต ะผะฐะนะพัะฐ
rus_verbs:ะผะตัะฐัั{}, // ะผะตัะฐัั ะฒ ัะตะปั
rus_verbs:ะฟัััะธัั{}, // ะฟัััะธัั ะฒ ะดะตะปะพ
rus_verbs:ะฟะพะปะตัะตัั{}, // ะฟะพะปะตัะตัั ะฒ ะะฒัะพะฟั
rus_verbs:ะฟัะพะฟัััะธัั{}, // ะฟัะพะฟัััะธัั ะฒ ะทะดะฐะฝะธะต
rus_verbs:ัะฒะฐะฝััั{}, // ัะฒะฐะฝััั ะฒ ะพัะฟััะบ
rus_verbs:ะทะฐั
ะพะดะธัั{}, // ะทะฐั
ะพะดะธัั ะฒ ะบะฐะผะพัะบั
rus_verbs:ะฝััะฝััั{}, // ะฝััะฝััั ะฒ ะฟัะพััะฑั
rus_verbs:ัะฒะฐะฝััััั{}, // ัะฒะฐะฝััััั ะฒ ะฐัะฐะบั
rus_verbs:ะฟัะธะฟะพะดะฝััััั{}, // ะฟัะธะฟะพะดะฝััััั ะฒ ะฒะพะทะดัั
rus_verbs:ะฟัะตะฒัะฐัะฐัััั{}, // ะฟัะตะฒัะฐัะฐัััั ะฒ ะบััะฟะฝัั ะฒะตะปะธัะธะฝั
rus_verbs:ะฟัะพะบัะธัะฐัั{}, // ะฟัะพะบัะธัะฐัั ะฒ ัั
ะพ
rus_verbs:ะทะฐะฟะธัะฐัั{}, // ะทะฐะฟะธัะฐัั ะฒ ะฑะปะพะบะฝะพั
rus_verbs:ะทะฐะฑัะฐัััั{}, // ะทะฐะฑัะฐัััั ะฒ ัะบะฐั
rus_verbs:ะฟัะธะตะทะถะฐัั{}, // ะฟัะธะตะทะถะฐัั ะฒ ะดะตัะตะฒะฝั
rus_verbs:ะฟัะพะดะฐัั{}, // ะฟัะพะดะฐัั ะฒ ัะฐะฑััะฒะพ
rus_verbs:ะฟัะพะฝะธะบะฝััั{}, // ะฟัะพะฝะธะบะฝััั ะฒ ัะตะฝัั
rus_verbs:ััััะตะผะธัััั{}, // ััััะตะผะธัััั ะฒ ะพัะบัััะพะต ะผะพัะต
rus_verbs:ะฟะพัะฐะดะธัั{}, // ะฟะพัะฐะดะธัั ะฒ ะบัะตัะปะพ
rus_verbs:ัะฟะตัะตัััั{}, // ัะฟะตัะตัััั ะฒ ะฟะพะป
rus_verbs:ัะธะฝััััั{}, // ัะธะฝััััั ะฒ ะฑััะตั
rus_verbs:ะพัะดะฐะฒะฐัั{}, // ะพัะดะฐะฒะฐัั ะฒ ะบะฐะดะตััะบะพะต ััะธะปะธัะต
rus_verbs:ะพัะปะพะถะธัั{}, // ะพัะปะพะถะธัั ะฒ ะดะพะปะณะธะน ััะธะบ
rus_verbs:ัะฑะตะถะฐัั{}, // ัะฑะตะถะฐัั ะฒ ะฟัะธัั
rus_verbs:ะพัะตะฝะธัั{}, // ะพัะตะฝะธัั ะฒ ะผะธะปะปะธะพะฝ ะดะพะปะปะฐัะพะฒ
rus_verbs:ะฟะพะดะฝะธะผะฐัั{}, // ะฟะพะดะฝะธะผะฐัั ะฒ ัััะฐัะพััะตัั
rus_verbs:ะพัะพัะปะฐัั{}, // ะพัะพัะปะฐัั ะฒ ะบะฒะฐะปะธัะธะบะฐัะธะพะฝะฝัั ะบะพะผะธััะธั
rus_verbs:ะพัะพะดะฒะธะฝััั{}, // ะพัะพะดะฒะธะฝััั ะฒ ะดะฐะปัะฝะธะน ัะณะพะป
rus_verbs:ัะพัะพะฟะธัััั{}, // ัะพัะพะฟะธัััั ะฒ ัะบะพะปั
rus_verbs:ะฟะพะฟะฐะดะฐัััั{}, // ะฟะพะฟะฐะดะฐัััั ะฒ ััะบะธ
rus_verbs:ะฟะพัะฐะทะธัั{}, // ะฟะพัะฐะทะธัั ะฒ ัะฐะผะพะต ัะตัะดัะต
rus_verbs:ะดะพััะฐะฒะธัั{}, // ะดะพััะฐะฒะธัั ะฒ ะบะฒะฐััะธัั
rus_verbs:ะทะฐัะปะฐัั{}, // ะทะฐัะปะฐัั ะฒ ััะป
rus_verbs:ัะพัะปะฐัั{}, // ัะพัะปะฐัั ะฒ ะธะทะณะฝะฐะฝะธะต
rus_verbs:ะทะฐะฟัััะธัั{}, // ะทะฐะฟัััะธัั ะฒ ะบะพัะผะพั
rus_verbs:ัะดะฐัะธัััั{}, // ัะดะฐัะธัััั ะฒ ะทะฐะฟะพะน
rus_verbs:ัะดะฐัััััั{}, // ัะดะฐัััััั ะฒ ะบัะฐะนะฝะพััั
rus_verbs:ัะตะฟัะฐัั{}, // ัะตะฟัะฐัั ะฒ ะปะธัะพ
rus_verbs:ััะพะฝะธัั{}, // ััะพะฝะธัั ะฒ ัะฝะธัะฐะท
rus_verbs:ะฟัะพัััะฐัั{}, // ะฟัะพัััะฐัั ะฒ ะผะธะบัะพัะพะฝ
rus_verbs:ะทะฐััะฝััั{}, // ะทะฐััะฝััั ะฒ ะณะปะพัะบั
rus_verbs:ะฟะปััั{}, // ะฟะปััั ะฒ ะพัะบัััะพะต ะผะพัะต
rus_verbs:ะฟะตัะตะฝะตััะธ{}, // ะฟะตัะตะฝะตััะธ ะฒ ะดัั
ะพะฒะบั
rus_verbs:ัะฒะตัะธัั{}, // ัะฒะตัะธัั ะฒ ะปะธัะพ
rus_verbs:ะผัะฐัััั{}, // ะผัะฐัััั ะฒ ัะตะผะพะฝั
rus_verbs:ัััะบะฝััั{}, // ัััะบะฝััั ะฒ ะปะพะฑ
rus_verbs:ะพะฑัััะธัััั{}, // ะพะฑัััะธัััั ะฒ ะบะพัะปะพะฒะฐะฝ
rus_verbs:ะฟะพะณะปัะดัะฒะฐัั{}, // ะฟะพะณะปัะดัะฒะฐัั ะฒ ัะบัะฐะฝ
rus_verbs:ัะปะพะถะธัั{}, // ัะปะพะถะธัั ะฒ ะบัะพะฒะฐัะบั
ะธะฝัะธะฝะธัะธะฒ:ะฟะพะฟะฐะดะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฟะพะฟะฐะดะฐัั ะฒ ัะตัะฝัะน ัะฟะธัะพะบ
ะณะปะฐะณะพะป:ะฟะพะฟะฐะดะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะพะฟะฐะดะฐััะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะพะฟะฐะดะฐะฒัะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะฟะพะฟะฐะดะฐั{},
rus_verbs:ะฟัะพะฒะฐะปะธัััั{}, // ะฟัะพะฒะฐะปะธัััั ะฒ ัะผั
rus_verbs:ะถะฐะปะพะฒะฐัััั{}, // ะถะฐะปะพะฒะฐัััั ะฒ ะบะพะผะธััะธั
rus_verbs:ะพะฟะพะทะดะฐัั{}, // ะพะฟะพะทะดะฐัั ะฒ ัะบะพะปั
rus_verbs:ะฟะพััะปะฐัั{}, // ะฟะพััะปะฐัั ะฒ ะฟะฐัะธะบะผะฐั
ะตััะบัั
rus_verbs:ะฟะพะณะฝะฐัั{}, // ะฟะพะณะฝะฐัั ะฒ ั
ะปะตะฒ
rus_verbs:ะฟะพัััะฟะฐัั{}, // ะฟะพัััะฟะฐัั ะฒ ะธะฝััะธััั
rus_verbs:ััะฐะดะธัั{}, // ััะฐะดะธัั ะฒ ะบัะตัะปะพ
rus_verbs:ะฟัะพะธะณัะฐัั{}, // ะฟัะพะธะณัะฐัั ะฒ ััะปะตัะบั
rus_verbs:ะฟัะธะปะตัะตัั{}, // ะฟัะธะปะตัะตัั ะฒ ัััะฐะฝั
rus_verbs:ะฟะพะฒะฐะปะธัััั{}, // ะฟะพะฒะฐะปะธัััั ะฒ ััะฐะฒั
rus_verbs:ะพะณััะทะฝััััั{}, // ะกะพะฑะฐะบะฐ ะพะณััะทะฝัะปะฐัั ะฒ ะพัะฒะตั
rus_verbs:ะปะตะทัั{}, // ะปะตะทัั ะฒ ััะถะธะต ะดะตะปะฐ
rus_verbs:ะฟะพัะฐัะธัั{}, // ะฟะพัะฐัะธัั ะฒ ััะด
rus_verbs:ะฝะฐะฟัะฐะฒะปััััั{}, // ะฝะฐะฟัะฐะฒะปััััั ะฒ ะฟะพัั
rus_verbs:ะฟะพะฟะพะปะทัะธ{}, // ะฟะพะฟะพะปะทัะธ ะฒ ะดััะณัั ััะพัะพะฝั
rus_verbs:ะฟัััะธัััั{}, // ะฟัััะธัััั ะฒ ะฟะปัั
rus_verbs:ะทะฐะฑะธัััั{}, // ะทะฐะฑะธัััั ะฒ ะฝะพัั
rus_verbs:ะทะฐะปะตะทัั{}, // ะทะฐะปะตะทัั ะฒ ะบะพะฝััั
rus_verbs:ัะดะฐัั{}, // ัะดะฐัั ะฒ ััะธะปั
rus_verbs:ััะพะฝััััั{}, // ััะพะฝััััั ะฒ ะฟััั
rus_verbs:ััะณัะฐัั{}, // ััะณัะฐัั ะฒ ัะฐั
ะผะฐัั
rus_verbs:ะฟะตัะตะฒะตัะฝััั{}, // ะฟะตัะตะฒะตัะฝััั ะฒ ะฑะพะปะตะต ัะดะพะฑะฝัั ะฟะพะทั
rus_verbs:ัะถะธะผะฐัั{}, // ัะถะธะผะฐัั ะฟะฐะปััั ะฒ ะบัะปะฐะบ
rus_verbs:ะฟะพะดัะพะปะบะฝััั{}, // ะฟะพะดัะพะปะบะฝััั ะฒ ะฑะพะบ
rus_verbs:ะพัะฝะตััะธ{}, // ะพัะฝะตััะธ ะถะธะฒะพัะฝะพะต ะฒ ะปะตัะตะฑะฝะธัั
rus_verbs:ะพะดะตัััั{}, // ะพะดะตัััั ะฒ ะทะธะผะฝัั ะพะดะตะถะดั
rus_verbs:ะฟะปัะฝััั{}, // ะฟะปัะฝััั ะฒ ะบะพะปะพะดะตั
rus_verbs:ะฟะตัะตะดะฐะฒะฐัั{}, // ะฟะตัะตะดะฐะฒะฐัั ะฒ ะฟัะพะบััะฐัััั
rus_verbs:ะพััะบะพัะธัั{}, // ะพััะบะพัะธัั ะฒ ะปะพะฑ
rus_verbs:ะฟัะธะทะฒะฐัั{}, // ะฟัะธะทะฒะฐัั ะฒ ะฐัะผะธั
rus_verbs:ัะฒะตะทัะธ{}, // ัะฒะตะทัะธ ะฒ ะดะตัะตะฒะฝั
rus_verbs:ัะปะตัััั{}, // ัะปะตัััั ะฒ ะบัะพะฒะฐัะบั
rus_verbs:ะพััะฐัะฝััััั{}, // ะพััะฐัะฝััััั ะฒ ััะพัะพะฝั
rus_verbs:ะปะพะถะธัััั{}, // ะปะพะถะธัััั ะฒ ะฟะพััะตะปั
rus_verbs:ะฟัะพะปะตัะตัั{}, // ะฟัะพะปะตัะตัั ะฒ ะบะพะฝะตั
rus_verbs:ะบะปะฐััั{}, // ะบะปะฐััั ะฒ ัะตะนั
rus_verbs:ะดะพััะฐะฒะปััั{}, // ะดะพััะฐะฒะปััั ะฒ ะบะฐะฑะธะฝะตั
rus_verbs:ะฟัะธะพะฑัะตัะฐัั{}, // ะฟัะธะพะฑัะตัะฐัั ะฒ ะบัะตะดะธั
rus_verbs:ัะฒะพะดะธัั{}, // ัะฒะพะดะธัั ะฒ ัะตะฐัั
rus_verbs:ัะฝะตััะธ{}, // ัะฝะตััะธ ะฒ ะผะพะณะธะปั
rus_verbs:ะฟะพะบะฐัะธัััั{}, // ะฟะพะบะฐัะธัััั ะฒ ัะผั
rus_verbs:ัั
ะพะดะธัั{}, // ัั
ะพะดะธัั ะฒ ะผะฐะณะฐะทะธะฝัะธะบ
rus_verbs:ัะฟัััะธัั{}, // ัะฟัััะธัั ะฒ ะบะฐะฝะฐะปะธะทะฐัะธั
rus_verbs:ะฟัะพะฝะธะบะฐัั{}, // ะฟัะพะฝะธะบะฐัั ะฒ ัะตัะดัะตะฒะธะฝั
rus_verbs:ะผะตัะฝััั{}, // ะผะตัะฝััั ะฒ ะฑะพะปะฒะฐะฝะฐ ะณะฝะตะฒะฝัะน ะฒะทะณะปัะด
rus_verbs:ะฟะพะถะฐะปะพะฒะฐัััั{}, // ะฟะพะถะฐะปะพะฒะฐัััั ะฒ ะฐะดะผะธะฝะธัััะฐัะธั
rus_verbs:ััััะฐัั{}, // ััััะฐัั ะฒ ะผะตัะฐะปะปะธัะตัะบัั ะดะฒะตัั
rus_verbs:ัะฐัะธัั{}, // ัะฐัะธัั ะฒ ัะตะผะพะฝั
rus_verbs:ะทะฐะณะปัะดัะฒะฐัั{}, // ะทะฐะณะปัะดัะฒะฐัั ะฒ ะพัะฒะตัั
rus_verbs:ะฟะปัั
ะฝััััั{}, // ะฟะปัั
ะฝััััั ะฒ ััะพะป ะฐัะพะผะฐัะฝะพะณะพ ัะตะฝะฐ
rus_verbs:ัะฒะตััะธ{}, // ัะฒะตััะธ ะฒ ัะปะตะดัััะธะน ะบะฐะฑะธะฝะตั
rus_verbs:ััะฟะตะฒะฐัั{}, // ััะฟะตะฒะฐัั ะฒ ัะบะพะปั
rus_verbs:ะฟัะพะฑัะฐัััั{}, // ะฟัะพะฑัะฐัััั ะฒ ัะพะฑะฐััั ะบะพะฝััั
rus_verbs:ะฟะพะดะฐะฒะฐัั{}, // ะฟะพะดะฐะฒะฐัั ะฒ ััะด
rus_verbs:ะฟัะธะฑะตะถะฐัั{}, // ะฟัะธะฑะตะถะฐัั ะฒ ะบะพะฝััะฝั
rus_verbs:ัะฐััะผะพััะตัั{}, // ัะฐััะผะพััะตัั ะฒ ะผะธะบัะพัะบะพะฟ
rus_verbs:ะฟะฝััั{}, // ะฟะฝััั ะฒ ะถะธะฒะพั
rus_verbs:ะทะฐะฒะตัะฝััั{}, // ะทะฐะฒะตัะฝััั ะฒ ะดะตะบะพัะฐัะธะฒะฝัั ะฟะปะตะฝะบั
rus_verbs:ัะตะทะถะฐัั{}, // ัะตะทะถะฐัั ะฒ ะดะตัะตะฒะฝั
rus_verbs:ะฟัะธะฒะปะตะบะฐัั{}, // ะฟัะธะฒะปะตะบะฐัั ะฒ ัะฒะพะธ ััะดั
rus_verbs:ะฟะตัะตะฑัะฐัััั{}, // ะฟะตัะตะฑัะฐัััั ะฒ ะฟัะธะฑัะตะถะฝัะน ะณะพัะพะด
rus_verbs:ะดะพะปะธัั{}, // ะดะพะปะธัั ะฒ ะบะพะบัะตะนะปั
rus_verbs:ะฟะฐะปะธัั{}, // ะฟะฐะปะธัั ะฒ ะฝะฐะฟะฐะดะฐััะธั
rus_verbs:ะพัะพะฑัะฐัั{}, // ะพัะพะฑัะฐัั ะฒ ะบะพะปะปะตะบัะธั
rus_verbs:ัะปะตัะตัั{}, // ัะปะตัะตัั ะฒ ะฝะตะธะทะฒะตััะฝะพััั
rus_verbs:ะฒัะณะปัะฝััั{}, // ะฒัะณะปัะฝััั ะฒ ะพะบะฝะพ
rus_verbs:ะฒัะณะปัะดัะฒะฐัั{}, // ะฒัะณะปัะดัะฒะฐัั ะฒ ะพะบะฝะพ
rus_verbs:ะฟัะพะฑะธัะฐัััั{}, // ะณัะฐะฑะธัะตะปั, ะฟัะพะฑะธัะฐััะธะนัั ะฒ ะดะพะผ
ะธะฝัะธะฝะธัะธะฒ:ะฝะฐะฟะธัะฐัั{ aux stress="ะฝะฐะฟะธั^ะฐัั"}, // ัะธัะฐัะตะปั, ะฝะฐะฟะธัะฐะฒัะธะน ะฒ ะฑะปะพะณ
ะณะปะฐะณะพะป:ะฝะฐะฟะธัะฐัั{ aux stress="ะฝะฐะฟะธั^ะฐัั"},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐะฟะธัะฐะฒัะธะน{ aux stress="ะฝะฐะฟะธั^ะฐะฒัะธะน"},
rus_verbs:ัะฒะตัะฝััั{}, // ัะฒะตัะฝััั ะฒ ะบะพะปะตัะบะพ
ะธะฝัะธะฝะธัะธะฒ:ัะฟะพะปะทะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ัะฟะพะปะทะฐัั ะฒ ะพะฒัะฐะณ
ะณะปะฐะณะพะป:ัะฟะพะปะทะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฟะพะปะทะฐััะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฟะพะปะทะฐะฒัะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ะฑะฐัะฐะฑะฐะฝะธัั{}, // ะฑะฐัะฐะฑะฐะฝะธัั ะฒ ะดะฒะตัั
rus_verbs:ะดะพะฟะธััะฒะฐัั{}, // ะดะพะฟะธััะฒะฐัั ะฒ ะบะพะฝะตั
rus_verbs:ะผะตะฝััััั{}, // ะผะตะฝััััั ะฒ ะปััััั ััะพัะพะฝั
rus_verbs:ะธะทะผะตะฝะธัััั{}, // ะธะทะผะตะฝะธัััั ะฒ ะปััััั ััะพัะพะฝั
rus_verbs:ะธะทะผะตะฝััััั{}, // ะธะทะผะตะฝััััั ะฒ ะปััััั ััะพัะพะฝั
rus_verbs:ะฒะฟะธัะฐัััั{}, // ะฒะฟะธัะฐัััั ะฒ ะฟะพะฒะพัะพั
rus_verbs:ะฒะฟะธััะฒะฐัััั{}, // ะฒะฟะธััะฒะฐัััั ะฒ ะฟะพะฒะพัะพัั
rus_verbs:ะฟะตัะตัะฐะฑะพัะฐัั{}, // ะฟะตัะตัะฐะฑะพัะฐัั ะฒ ัะดะพะฑัะตะฝะธะต
rus_verbs:ะฟะตัะตัะฐะฑะฐััะฒะฐัั{}, // ะฟะตัะตัะฐะฑะฐััะฒะฐัั ะฒ ัะดะพะฑัะตะฝะธะต
rus_verbs:ัะฟะพะปะทะฐัั{}, // ัะฟะพะปะทะฐัั ะฒ ัะตะฝั
rus_verbs:ะทะฐะฟะพะปะทะฐัั{}, // ะทะฐะฟะพะปะทะฐัั ะฒ ะฝะพัั
rus_verbs:ะฟะตัะตะฟัััะฐัั{}, // ะฟะตัะตะฟัััะฐัั ะฒ ัะบัะพะผะฝะพะต ะผะตััะพ
rus_verbs:ะทะฐัะฐะปะบะธะฒะฐัั{}, // ะทะฐัะฐะปะบะธะฒะฐัั ะฒ ะฒะฐะณะพะฝ
rus_verbs:ะฟัะตะพะฑัะฐะทะพะฒัะฒะฐัั{}, // ะฟัะตะพะฑัะฐะทะพะฒัะฒะฐัั ะฒ ัะฟะธัะพะบ
ะธะฝัะธะฝะธัะธะฒ:ะบะพะฝะฒะตััะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะบะพะฝะฒะตััะธัะพะฒะฐัั ะฒ ัะฟะธัะพะบ
ะณะปะฐะณะพะป:ะบะพะฝะฒะตััะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะธะฝัะธะฝะธัะธะฒ:ะบะพะฝะฒะตััะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะณะปะฐะณะพะป:ะบะพะฝะฒะตััะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะบะพะฝะฒะตััะธัะพะฒะฐะฒ{},
ะดะตะตะฟัะธัะฐััะธะต:ะบะพะฝะฒะตััะธััั{},
rus_verbs:ะธะทะพัะฒะฐัั{}, // ะะฝ ะธะทะพัะฒะฐะป ะณะฐะทะตัั ะฒ ะบะปะพัะบะธ.
rus_verbs:ะฒัั
ะพะดะธัั{}, // ะะบะฝะฐ ะฒัั
ะพะดัั ะฒ ัะฐะด.
rus_verbs:ะณะพะฒะพัะธัั{}, // ะะฝ ะณะพะฒะพัะธะป ะฒ ะทะฐัะธัั ัะฒะพะตะณะพ ะพััะฐ.
rus_verbs:ะฒััะฐััะฐัั{}, // ะะฝ ะฒััะฐััะฐะตั ะฒ ะฑะพะปััะพะณะพ ั
ัะดะพะถะฝะธะบะฐ.
rus_verbs:ะฒัะฒะตััะธ{}, // ะะฝ ะฒัะฒะตะป ะดะตัะตะน ะฒ ัะฐะด.
// ะธะฝัะธะฝะธัะธะฒ:ะฒััะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ะฒััะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
// ะณะปะฐะณะพะป:ะฒััะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฒััะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะะฝ ะฒััะฟะฐะป ะฒ ะฒะพะดั ะดะฒะต ะปะพะถะบะธ ัะพะปะธ.
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฐะฝะตะฝัะน{}, // ะะฝ ะฑัะป ัะฐะฝะตะฝ ะฒ ะปะตะฒัั ััะบั.
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะพะดะตััะน{}, // ะะฝ ะฑัะป ะพะดะตั ะฒ ัะพะปััะพะต ะพัะตะฝะฝะตะต ะฟะฐะปััะพ.
rus_verbs:ะฑัั
ะฝััััั{}, // ะะฝ ะฑัั
ะฝัะปัั ะฒ ะฒะพะดั.
rus_verbs:ัะบะปะพะฝััั{}, // ัะบะปะพะฝััั ะทะฐัะธัั ะฒ ัะฒะพั ะฟะพะปัะทั
rus_verbs:ะฒะฟะธัััั{}, // ะะธัะฒะบะฐ ะฒะฟะธะปะฐัั ะฒ ัะตะปะพ.
rus_verbs:ัั
ะพะดะธัััั{}, // ะะฝัะตะปะปะธะณะตะฝัั ะฝะฐัะฐะปะฐ ะฒะตะบะฐ ัะฐััะพ ัั
ะพะดะธะปะธัั ะฒ ัะฐะทะฝัะต ัะพัะทั
rus_verbs:ัะพั
ัะฐะฝััั{}, // ัะพั
ัะฐะฝะธัั ะดะฐะฝะฝัะต ะฒ ัะฐะนะป
rus_verbs:ัะพะฑะธัะฐัั{}, // ัะพะฑะธัะฐัั ะธะณัััะบะธ ะฒ ััะธะบ
rus_verbs:ัะฟะฐะบะพะฒัะฒะฐัั{}, // ัะฟะฐะบะพะฒัะฒะฐัั ะฒะตัะธ ะฒ ัะตะผะพะดะฐะฝ
rus_verbs:ะพะฑัะฐัะฐัััั{}, // ะะฑัะฐัะฐะนัะตัั ะบะพ ะผะฝะต ะฒ ะปัะฑะพะต ะฒัะตะผั
rus_verbs:ัััะตะปัะฝััั{}, // ัััะตะปัะฝะธ ะฒ ัะพะปะฟั!
rus_verbs:ะฟัะปััั{}, // ะฟัะปัะน ะฒ ัะพะปะฟั
rus_verbs:ะฟัะปัะฝััั{}, // ะฟัะปัะฝะธ ะฒ ัะพะปะฟั
rus_verbs:ััะฐะฝะพะฒะธัััั{}, // ะกัะฐะฝะพะฒะธัะตัั ะฒ ะพัะตัะตะดั.
rus_verbs:ะฒะฟะธัะฐัั{}, // ะฎะปั ะฒะฟะธัะฐะปะฐ ัะฒะพะต ะธะผั ะฒ ัะฟะธัะพะบ.
rus_verbs:ะฒะฟะธััะฒะฐัั{}, // ะั ะฒะฟะธััะฒะฐะปะธ ัะฒะพะธ ะธะผะตะฝะฐ ะฒ ัะฟะธัะพะบ
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒะธะดะฝัะน{}, // ะะปะฐะฝะตัะฐ ะะฐัั ะฒะธะดะฝะฐ ะฒ ะพะฑััะฝัะน ะฑะธะฝะพะบะปั
rus_verbs:ะฟะพะนัะธ{}, // ะะตะฒะพัะบะฐ ัะฐะฝะพ ะฟะพัะปะฐ ะฒ ัะบะพะปั
rus_verbs:ะพัะพะนัะธ{}, // ะญัะธ ะพะฑััะฐะธ ะพัะพัะปะธ ะฒ ะธััะพัะธั.
rus_verbs:ะฑะธัั{}, // ะฅะพะปะพะดะฝัะน ะฒะตัะตั ะฑะธะป ะตะผั ะฒ ะปะธัะพ.
rus_verbs:ะฒั
ะพะดะธัั{}, // ะญัะพ ะฒั
ะพะดะธั ะฒ ะตะณะพ ะพะฑัะทะฐะฝะฝะพััะธ.
rus_verbs:ะฟัะธะฝััั{}, // ะผะตะฝั ะฟัะธะฝัะปะธ ะฒ ะฟะธะพะฝะตัั
rus_verbs:ัะนัะธ{}, // ะัะฐะฒะธัะตะปัััะฒะพ ะ ะค ััะปะพ ะฒ ะพัััะฐะฒะบั
rus_verbs:ะดะพะฟัััะธัั{}, // ะฏะฟะพะฝะธั ะฑัะปะฐ ะดะพะฟััะตะฝะฐ ะฒ ะัะณะฐะฝะธะทะฐัะธั ะะฑัะตะดะธะฝัะฝะฝัั
ะะฐัะธะน ะฒ 1956 ะณะพะดั.
rus_verbs:ะฟะพัะฒััะธัั{}, // ะฏ ะฟะพัะฒััะธะป ะดััะณะฐ ะฒ ัะฒะพั ัะฐะนะฝั.
ะธะฝัะธะฝะธัะธะฒ:ัะบัะฟะพััะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะบัะฟะพััะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ัะบัะฟะพััะธัะพะฒะฐัั ะฝะตััั ะฒ ัััะฐะฝั ะะพััะพะบะฐ
rus_verbs:ะฒะทะณะปัะฝััั{}, // ะฏ ะฝะต ัะผะตะป ะฒะทะณะปัะฝััั ะตะผั ะฒ ะณะปะฐะทะฐ.
rus_verbs:ะธะดัะธ{}, // ะฏ ะธะดั ะณัะปััั ะฒ ะฟะฐัะบ.
rus_verbs:ะฒัะบะพัะธัั{}, // ะฏ ะฒัะบะพัะธะป ะฒ ััะฐะผะฒะฐะน ะธ ะฟะพะผัะฐะปัั ะฒ ะธะฝััะธััั.
rus_verbs:ะฟะพะปััะธัั{}, // ะญัั ะผะตะฑะตะปั ะผั ะฟะพะปััะธะปะธ ะฒ ะฝะฐัะปะตะดััะฒะพ ะพั ัะพะดะธัะตะปะตะน.
rus_verbs:ะฒะตะทัะธ{}, // ะฃัะธัะตะปั ะฒะตะทัั ะดะตัะตะน ะฒ ะปะฐะณะตัั.
rus_verbs:ะบะฐัะฐัั{}, // ะกัะดะฝะพ ะบะฐัะฐะตั ะฒะพ ะฒัะต ััะพัะพะฝั.
rus_verbs:ะทะฐะตะทะถะฐัั{}, // ะกะตะณะพะดะฝั ะฒะตัะตัะพะผ ั ะทะฐะตะทะถะฐะป ะฒ ะผะฐะณะฐะทะธะฝ ะทะฐ ะบะฝะธะณะฐะผะธ.
rus_verbs:ัะฒัะทะฐัั{}, // ะกะฒัะถะธัะต ัะฒะพะธ ะฒะตัะธ ะฒ ัะทะตะปะพะบ.
rus_verbs:ะฟัะพะฝะตััะธ{}, // ะัะพะฝะตัะธัะต ััะพะป ะฒ ะดะฒะตัั.
rus_verbs:ะฒัะฝะตััะธ{}, // ะะฐะดะพ ะฒัะฝะตััะธ ะฟัะธะผะตัะฐะฝะธั ะฒ ะบะพะฝะตั.
rus_verbs:ััััะพะธัั{}, // ะะฝะฐ ััััะพะธะปะฐ ััะฝะฐ ะฒ ัะบะพะปั.
rus_verbs:ัะณะพะดะธัั{}, // ะะฝะฐ ัะณะพะดะธะปะฐ ะณะพะปะพะฒะพะน ะฒ ะดะฒะตัั.
rus_verbs:ะพัะฒะตัะฝััััั{}, // ะะฝะฐ ัะตะทะบะพ ะพัะฒะตัะฝัะปะฐัั ะฒ ััะพัะพะฝั.
rus_verbs:ัะฐััะผะฐััะธะฒะฐัั{}, // ะะฝะฐ ัะฐััะผะฐััะธะฒะฐะปะฐ ััะตะฝั ะฒ ะฑะธะฝะพะบะปั.
rus_verbs:ะพะฑัะฐัะธัั{}, // ะะพะนะฝะฐ ะพะฑัะฐัะธะปะฐ ะณะพัะพะด ะฒ ัะฐะทะฒะฐะปะธะฝั.
rus_verbs:ัะพะนัะธัั{}, // ะั ัะพัะปะธัั ะฒ ัะบะพะปัะฝัะต ะณะพะดั.
rus_verbs:ะฟัะธะตั
ะฐัั{}, // ะั ะฟัะธะตั
ะฐะปะธ ะฒ ะฟะพะปะพะถะตะฝะฝัะน ัะฐั.
rus_verbs:ะฒััะฐัั{}, // ะะตัะธ ะฒััะฐะปะธ ะฒ ะบััะณ.
rus_verbs:ะฒะฟะฐััั{}, // ะะท-ะทะฐ ะฑะพะปะตะทะฝะธ ะพะฝ ะฒะฟะฐะป ะฒ ะฝัะถะดั.
rus_verbs:ะฟัะธะดัะธ{}, // ะฟัะธะดัะธ ะฒ ัะฟะฐะดะพะบ
rus_verbs:ะทะฐัะฒะธัั{}, // ะะฐะดะพ ะทะฐัะฒะธัั ะฒ ะผะธะปะธัะธั ะพ ะบัะฐะถะต.
rus_verbs:ะทะฐัะฒะปััั{}, // ะทะฐัะฒะปััั ะฒ ะฟะพะปะธัะธั
rus_verbs:ะตั
ะฐัั{}, // ะั ะฑัะดะตะผ ะตั
ะฐัั ะฒ ะััะป
rus_verbs:ะพะบัะฐัะธะฒะฐัััั{}, // ะพะบัะฐัะธะฒะฐัััั ะฒ ะบัะฐัะฝัะน ัะฒะตั
rus_verbs:ัะตัะธัั{}, // ะะตะปะพ ัะตัะตะฝะพ ะฒ ะฟะพะปัะทั ะธัััะฐ.
rus_verbs:ัะตััั{}, // ะะฝะฐ ัะตะปะฐ ะฒ ะบัะตัะปะพ
rus_verbs:ะฟะพัะผะพััะตัั{}, // ะะฝะฐ ะฟะพัะผะพััะตะปะฐ ะฝะฐ ัะตะฑั ะฒ ะทะตัะบะฐะปะพ.
rus_verbs:ะฒะปะตะทะฐัั{}, // ะพะฝ ะฒะปะตะทะฐะตั ะฒ ะผะพั ะบะฒะฐััะธัะบั
rus_verbs:ะฟะพะฟะฐััััั{}, // ะฒ ะผะพั ะปะพะฒััะบั ะฟะพะฟะฐะปะฐัั ะผััั
rus_verbs:ะปะตัะตัั{}, // ะั ะปะตัะธะผ ะฒ ะััะป
ะะ_ะะะค(ะฑัะฐัั), // ะพะฝ ะฑะตัะตั ะฒ ัะฒะพั ะฟัะฐะฒัั ััะบั ะพัะตะฝั ััะถะตะปัะน ัะตััะฐะฒัะน ะบะฐะผะตะฝั
ะะ_ะะะค(ะฒะทััั), // ะะพะปั ะฒะทัะป ะฒ ััะบั ะบะฐะผะตะฝั
ะะ_ะะะค(ะฟะพะตั
ะฐัั), // ะฟะพะตั
ะฐัั ะฒ ะบััะธะท
ะะ_ะะะค(ะฟะพะดะฐัั), // ะฟะพะดะฐัั ะฒ ะพัััะฐะฒะบั
ะธะฝัะธะฝะธัะธะฒ:ะทะฐััะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะทะฐััะฟะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ะทะฐััะฟะฐัั ะฟะตัะพะบ ะฒ ััะธะบ
ะธะฝัะธะฝะธัะธะฒ:ะทะฐััะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั ะฟะตัะตั
ะพะดะฝะพััั:ะฟะตัะตั
ะพะดะฝัะน }, ะณะปะฐะณะพะป:ะทะฐััะฟะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั ะฟะตัะตั
ะพะดะฝะพััั:ะฟะตัะตั
ะพะดะฝัะน }, // ะทะฐััะฟะฐัั ะฟะตัะพะบ ะฒ ััะธะบ
ะะ_ะะะค(ะฒะฟะฐะดะฐัั), ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒะฟะฐะดะฐััะธะน{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒะฟะฐะดะฐะฒัะธะน{}, ะดะตะตะฟัะธัะฐััะธะต:ะฒะฟะฐะดะฐั{}, // ะฒะฟะฐะดะฐัั ะฒ ะผะพัะต
ะะ_ะะะค(ะฟะพััััะฐัั) // ะฟะพััััะฐัั ะฒ ะดะฒะตัั
}
// ะงัะพะฑั ัะฐะทัะตัะธัั ัะฒัะทัะฒะฐะฝะธะต ะฒ ะฟะฐััะตัะฝะฐั
ัะธะฟะฐ: ัะนัะธ ะฒ BEA Systems
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะ_ะะธะฝ ะฟัะตะดะปะพะณ:ะฒ{} @regex("[a-z]+[0-9]*") }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะ_ะะธะฝ ะฟัะตะดะปะพะณ:ะฒ{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะณะปะฐะณะพะป:ะฟะพะดะฒัะฒะฐัั{} ะฟัะตะดะปะพะณ:ะฒ{} ัััะตััะฒะธัะตะปัะฝะพะต:ัะฐะบั{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return true
}
#endregion ะะธะฝะธัะตะปัะฝัะน
// ะัะต ะพััะฐะปัะฝัะต ะฒะฐัะธะฐะฝัั ะฟะพ ัะผะพะปัะฐะฝะธั ะทะฐะฟัะตัะฐะตะผ.
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฒ{} *:*{ ะฟะฐะดะตะถ:ะฟัะตะดะป } }
then return false,-3
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฒ{} *:*{ ะฟะฐะดะตะถ:ะผะตัั } }
then return false,-3
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฒ{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return false,-4
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฒ{} * }
then return false,-5
}
#endregion ะัะตะดะปะพะณ_ะ
#region ะัะตะดะปะพะณ_ะะ
// ------------------- ะก ะะ ะะะะะะะ 'ะะ' ---------------------------
#region ะะ ะะะะะะะซะ
// ะะ+ะฟัะตะดะปะพะถะฝัะน ะฟะฐะดะตะถ:
// ะะะะะขะฌ ะะ ะกะขะะะ
#region VerbList
wordentry_set ะะป_ะะ_ะัะตะดะป=
{
rus_verbs:ะทะฐัะปััะฐัั{}, // ะะพะฟัะพั ะทะฐัะปััะฐะปะธ ะฝะฐ ัะตััะธะธ ะพะฑะปัะพะฒะตัะฐ
rus_verbs:ะะ ะะกะขะฃะะะขะฌ{}, // ะะฐ ะปะฑั, ะฝะพัั ะธ ัะตะบะต ะฟัะพัััะฟะฐะปะพ ัะตัะฝะพะต ะฟััะฝะพ ะบัะพะฒะพะฟะพะดัะตะบะฐ. (ะะ ะะกะขะฃะะะขะฌ/ะะ ะะกะขะฃะะะขะฌ)
rus_verbs:ะะ ะะกะขะฃะะะขะฌ{}, //
rus_verbs:ะะะะะะขะฌะกะฏ{}, // ะะฐ ะดััะณะพะน ััะพัะพะฝะต ะะบะตะฐะฝะฐ ะฒะธะดะฝะตะปะฐัั ะฟะพะปะพัะบะฐ ัััะธ, ะพะบััะถะฐะฒัะฐั ะฝะธะถะฝะธะน ัััั ะฟะปะฐะฝะตัั. (ะะะะะะขะฌะกะฏ)
rus_verbs:ะะะะะกะะขะฌ{}, // ะะฐัะธะฝะฐ ัะผะตะปะฐ ะทะฐะฒะธัะฐัั ะฒ ะฒะพะทะดัั
ะต ะฝะฐ ะปัะฑะพะน ะฒััะพัะต (ะะะะะกะะขะฌ)
rus_verbs:ะะะะะ ะะขะฌ{}, // ะกะบะพะปัะทะฝัะฒ ะฟะพ ััะฐะฒะต, ะพะฝ ะทะฐะผะตั ะฝะฐ ะฑะพะบั (ะะะะะ ะะขะฌ, ะปะพะบะฐัะธะฒ)
rus_verbs:ะะะะะ ะะขะฌ{}, //
rus_verbs:ะะะะ ะะะะขะฌ{}, // ะะฝ ะฒัััะธะป ะตะน ะปะธัะฝะธะน ะบะธะฝะถะฐะป, ะบะพัะพััะน ะพะฝะฐ ะฒะพัะบะฝัะปะฐ ะฒ ััะฑะฐั
ั ะธ ะทะฐะบัะตะฟะธะปะฐ ะฝะฐ ะฟะพะดะพะปะต. (ะะะะ ะะะะขะฌ)
rus_verbs:ะฃะะะะะขะ{}, // ะะฒะตัั ะทะฐะฒะธะทะถะฐะป ะธ ะฟะพะฟััะฐะปัั ัะฟะพะปะทัะธ ะฝะฐ ะดะฒัั
ะฝะตะฒัะตะดะธะผัั
ะฟะตัะตะดะฝะธั
ะฝะพะณะฐั
. (ะฃะะะะะขะ/ะฃะะะะะะขะฌ)
rus_verbs:ะฃะะะะะะขะฌ{}, //
rus_verbs:ะะะะขะะขะฌะกะฏ{}, // ะขะตะปะพ ะตะณะพ ะฑัะดะตั ะฑะพะปัะฐัััั ะฝะฐ ะฟัะพัััะฐะฝััะฒะตะฝะฝัั
ะฒะตััะฐั
, ะฟะพะบะฐ ะฝะต ัะณะฝะธะตั ะฒะตัะตะฒะบะฐ. (ะะะะขะะขะฌะกะฏ)
rus_verbs:ะ ะะะะะ ะะฃะขะฌ{}, // ะคะธะปะธะฟะฟะธะฝั ัะฐะทัะตัะฐั ะกะจะ ัะฐะทะฒะตัะฝััั ะฒะพะตะฝะฝัะต ะฑะฐะทั ะฝะฐ ัะฒะพะตะน ัะตััะธัะพัะธะธ (ะ ะะะะะ ะะฃะขะฌ)
rus_verbs:ะะะะฃะงะะขะฌ{}, // ะฏ ะฟััะฐะปัั ัะทะฝะฐัั ัะตะบัะตัั ะธ ะฟะพะปััะธัั ัะพะฒะตัั ะฝะฐ ะพัะธัะธะฐะปัะฝะพะผ ััััะบะพัะทััะฝะพะผ ัะพััะผะต (ะะะะฃะงะะขะฌ)
rus_verbs:ะะะกะะฏะขะฌ{}, // ะะฝ ะฐะบัะธะฒะธัะพะฒะฐะป ัะฟัะฐะฒะปะตะฝะธะต, ะธ ะฝะฐ ัะบัะฐะฝะต ัะฝะพะฒะฐ ะทะฐัะธัะปะพ ะธะทะพะฑัะฐะถะตะฝะธะต ะฟะพะปัะผะตัััะฐ. (ะะะกะะฏะขะฌ)
rus_verbs:ะะะะ ะะะขะฌะกะฏ{}, // ะกะผะตััะฝะธะบ ะฒะทะพัะฒะฐะปัั ะฝะฐ ะฟัะตะดะฒัะฑะพัะฝะพะผ ะผะธัะธะฝะณะต ะฒ ะะฐะบะธััะฐะฝะต (ะะะะ ะะะขะฌะกะฏ)
rus_verbs:ะธัะบัะธัััั{},
rus_verbs:ะะะะ ะะะะะขะฌ{}, // ะะฐ ะฒัะฑะพัะฐั
ะฒ ะธัะฐะฝัะบะธะน ะฟะฐัะปะฐะผะตะฝั ะฟะพะฑะตะดั ะพะดะตัะถะธะฒะฐัั ะฟัะพัะธะฒะฝะธะบะธ ะดะตะนััะฒัััะตะณะพ ะฟัะตะทะธะดะตะฝัะฐ (ะะะะ ะะะะะขะฌ)
rus_verbs:ะะ ะะกะะงะฌ{}, // ะะฐ ะฃะบัะฐะธะฝะต ะฟัะตัะตะบะปะธ ะดะตัะทะบะธะน ะฟะพะฑะตะณ ะทะฐะบะปััะตะฝะฝัั
ะฝะฐ ะฒะตััะพะปะตัะต (ะะ ะะกะะงะฌ)
rus_verbs:ะฃะะะขะะขะฌ{}, // ะะพะปัะน ะฝะพัะฒะตะถะตั ัะปะตัะตะป ะฝะฐ ะปัะถะฐั
ั ััะฐะผะฟะปะธะฝะฐ ะฝะฐ 60 ะผะตััะพะฒ (ะฃะะะขะะขะฌ)
rus_verbs:ะะ ะะฅะะะะขะฌ{}, // ัะบััะฒะฐััะธะนัั ะฒ ะปะตัั ะฐะผะตัะธะบะฐะฝัะบะธะน ะฟะพะดัะพััะพะบ ะฟัะพั
ะพะดะธะป ะธะฝะธัะธะฐัะธั ะฝะฐ ะพั
ะพัะต, ะฒัะฟะธะฒ ะบััะถะบั ะบัะพะฒะธ ะฟะตัะฒะพะณะพ ัะฑะธัะพะณะพ ะธะผ ะพะปะตะฝั (ะะ ะะฅะะะะขะฌ)
rus_verbs:ะกะฃะฉะะกะขะะะะะขะฌ{}, // ะะฐ ะะฐััะต ัััะตััะฒะพะฒะฐะปะธ ััะปะพะฒะธั ะดะปั ะถะธะทะฝะธ (ะกะฃะฉะะกะขะะะะะขะฌ)
rus_verbs:ะฃะะะะะขะฌ{}, // ะะพะฑะตะดั ะฒ ะะธะณะต ัะตะผะฟะธะพะฝะพะฒ ัะบะฐะถัั ะฝะฐ ัะฐัะฐั
(ะฃะะะะะขะฌ)
rus_verbs:ะพัะฒะตััะธ{}, // ะพัะฒะตััะธ ะดััั ะฝะฐ ะปัะดัั
rus_verbs:ัั
ะพะดะธัััั{}, // ะะฑะฐ ะฟัะพัะตััะพัะฐ ัั
ะพะดะธะปะธัั ะฝะฐ ัะพะผ, ััะพ ะฒ ัะตัะตะฟะฝะพะน ะบะพัะพะฑะบะต ะดะธะฝะพะทะฐะฒัะฐ
rus_verbs:ัะพะนัะธัั{},
rus_verbs:ะะะะะ ะฃะะะขะฌ{}, // ะะพะบะฐะทะฐัะตะปัััะฒะพ ะฝะฐะปะธัะธั ะฟะพะดะฟะพะฒะตัั
ะฝะพััะฝะพะณะพ ะพะบะตะฐะฝะฐ ะฝะฐ ะะฒัะพะฟะต ะพะฑะฝะฐััะถะตะฝะพ ะฝะฐ ะตั ะฟะพะฒะตัั
ะฝะพััะธ (ะะะะะ ะฃะะะขะฌ)
rus_verbs:ะะะะะฎะะะขะฌะกะฏ{}, // ะ ะตะดะบะธะน ะทะพะดะธะฐะบะฐะปัะฝัะน ัะฒะตั ะฒัะบะพัะต ะฑัะดะตั ะฝะฐะฑะปัะดะฐัััั ะฝะฐ ะฝะพัะฝะพะผ ะฝะตะฑะต (ะะะะะฎะะะขะฌะกะฏ)
rus_verbs:ะะะกะขะะะะฃะขะฌ{}, // ะะฐ ะฒัะตั
ะฐะฒะฐัะธะนะฝัั
ัะตะฐะบัะพัะฐั
ะดะพััะธะณะฝััะพ ัะพััะพัะฝะธะต ัะฐะบ ะฝะฐะทัะฒะฐะตะผะพะน ั
ะพะปะพะดะฝะพะน ะพััะฐะฝะพะฒะบะธ (ะะะกะขะะะะฃะขะฌ/ะะะกะขะะงะฌ)
ะณะปะฐะณะพะป:ะะะกะขะะงะฌ{},
ะธะฝัะธะฝะธัะธะฒ:ะะะกะขะะงะฌ{},
rus_verbs:ะทะฐะฒะตััะธัั{}, // ะ ะพััะธะนัะบะธะต ะฑะธะฐัะปะพะฝะธััั ะทะฐะฒะตััะธะปะธ ัะตะผะฟะธะพะฝะฐั ะผะธัะฐ ะฝะฐ ะผะฐะถะพัะฝะพะน ะฝะพัะต
rus_verbs:ะ ะะกะะะะะซะะะขะฌ{},
rus_verbs:ะคะะะฃะกะะ ะะะะขะฌะกะฏ{}, // ะะฝะฒะตััะพัั ะฟัะตะดะฟะพัะธัะฐัั ัะพะบััะธัะพะฒะฐัััั ะฝะฐ ััะตะดะฝะตััะพัะฝัั
ะพะถะธะดะฐะฝะธัั
(ะคะะะฃะกะะ ะะะะขะฌะกะฏ)
rus_verbs:ะะะกะะ ะะะะะะขะฌ{}, // ะบะฐะบ ะฝะตัะตััะตะทะฝะพ ะฒะพัะฟัะธะฝะธะผะฐะปะธ ะตะณะพ ะฝะฐ ะฒัะฑะพัะฐั
ะผััะฐ (ะะะกะะ ะะะะะะขะฌ)
rus_verbs:ะะฃะจะะะะขะฌ{}, // ะฝะฐ ัะตััะธัะพัะธะธ ะขะฒะตััะบะพะน ะพะฑะปะฐััะธ ะฑััะตะฒะฐะปะฐ ะณัะพะทะฐ , ะฒ ัะตะทัะปััะฐัะต ะบะพัะพัะพะน ะฟัะพะธะทะพัะปะพ ะพัะบะปััะตะฝะธะต ัะปะตะบััะพัะฝะฐะฑะถะตะฝะธั ะฒ ััะดะต ะผัะฝะธัะธะฟะฐะปัะฝัั
ะพะฑัะฐะทะพะฒะฐะฝะธะน ัะตะณะธะพะฝะฐ (ะะฃะจะะะะขะฌ)
rus_verbs:ะฃะงะะกะขะะขะฌะกะฏ{}, // ะ ะฟะพัะปะตะดะฝะธะต ะผะตัััั ะฒ ะทะพะฝะต ะพัะฒะตัััะฒะตะฝะฝะพััะธ ะฑัะฝะดะตัะฒะตัะฐ ะฝะฐ ัะตะฒะตัะต ะัะณะฐะฝะธััะฐะฝะฐ ััะฐััะธะปะธัั ัะปััะฐะธ ะพะฑัััะตะปะพะฒ ะฟะพะปะตะฒัั
ะปะฐะณะตัะตะน ะฝะตะผะตัะบะธั
ะผะธัะพัะฒะพััะตะฒ (ะฃะงะะกะขะะขะฌะกะฏ)
rus_verbs:ะะซะะะ ะะขะฌ{}, // ะะพัะตะผั ะถะตะฝัะบะฐั ัะฑะพัะฝะฐั ะ ะพััะธะธ ะฝะต ะผะพะถะตั ะฒัะธะณัะฐัั ะผะตะดะฐะปั ะฝะฐ ัะตะผะฟะธะพะฝะฐัะต ะผะธัะฐ (ะะซะะะ ะะขะฌ)
rus_verbs:ะะ ะะะะกะขะฌ{}, // ะัะพะฟะฐะฒัะธะผ ะฝะฐ ะฟัะพะณัะปะบะต ะฐะบัะตัะพะผ ะทะฐะธะฝัะตัะตัะพะฒะฐะปะธัั ัะปะตะดะพะฒะฐัะตะปะธ (ะะ ะะะะกะขะฌ)
rus_verbs:ะฃะะะขะฌ{}, // ะกะธะปะพะฒะธะบะธ ัะฑะธะปะธ ะดะฒัั
ะฑะพะตะฒะธะบะพะฒ ะฝะฐ ะฐะดะผะธะฝะธัััะฐัะธะฒะฝะพะน ะณัะฐะฝะธัะต ะะฝะณััะตัะธะธ ะธ ะงะตัะฝะธ (ะฃะะะขะฌ)
rus_verbs:ะฟะพะดะฟััะณะฝััั{}, // ะบะพะฑะตะปั ะฝะตะปะตะฟะพ ะฟะพะดะฟััะณะฝัะป ะฝะฐ ััะตั
ะฝะพะณะฐั
, ะฐ ะตะณะพ ั
ะพะทัะธะฝ ะพัะฟัะฐะฒะธะป ััััั ะฟะธะฒะฐ ะผะธะผะพ ััะฐ
rus_verbs:ะฟะพะดะฟััะณะธะฒะฐัั{},
rus_verbs:ะฒััะฒะตัะธัััั{}, // ะฝะฐ ะบะพะผะฟัััะตัะต ะฒััะฒะตัะธััั ัะฒะพั ะฟะพะดะฟะธัั
rus_verbs:ัะธะณััะธัะพะฒะฐัั{}, // ะตะณะพ ะฟะพัััะตั ัะธะณััะธััะตั ะฝะฐ ัััะฐะฝะธัะฐั
ะฟะตัะฐัะธ ะธ ัะตะปะตัะบัะฐะฝะฐั
rus_verbs:ะดะตะนััะฒะพะฒะฐัั{}, // ะฒััะฒะปะตะฝะฝัะน ะบะพะฝััะฐะฑะฐะฝะดะฝัะน ะบะฐะฝะฐะป ะดะตะนััะฒะพะฒะฐะป ะฝะฐ ะฟะพััะพัะฝะฝะพะน ะพัะฝะพะฒะต
rus_verbs:ะกะะฅะ ะะะะขะฌะกะฏ{}, // ะะฐ ััะฝะบะต ะผะตะถะดัะฝะฐัะพะดะฝัั
ัะดะตะปะพะบ IPO ัะพั
ัะฐะฝะธััั ะฒััะพะบะฐั ะฐะบัะธะฒะฝะพััั (ะกะะฅะ ะะะะขะฌะกะฏ ะะ)
rus_verbs:ะะ ะะะขะ{}, // ะะตะพะฑััะฝัะน ะบะพะฝะบััั ะฟัะพััะป ะฝะฐ ัะตะฒะตัะต ะจะฒะตัะธะธ (ะะ ะะะขะ ะะ ะฟัะตะดะป)
rus_verbs:ะะะงะะขะฌะกะฏ{}, // ะะฐ ัะตะฒะตัะพ-ะฒะพััะพะบะต ะกะจะ ะฝะฐัะฐะปะฐัั ัะธะปัะฝะฐั ัะฝะตะถะฝะฐั ะฑััั. (ะะะงะะขะฌะกะฏ ะะ ะฟัะตะดะป)
rus_verbs:ะะะะะะะะฃะขะฌ{}, // ะะพะฝัะปะธะบั ะฒะพะทะฝะธะบ ะฝะฐ ะฟะพัะฒะต ัะพะฒะผะตััะฝะพะน ะบะพะผะผะตััะตัะบะพะน ะดะตััะตะปัะฝะพััะธ ะฟะพ ะฒััะฐัะธะฒะฐะฝะธั ะพะฒะพัะตะน ะธ ะทะตะปะตะฝะธ (ะะะะะะะะฃะขะฌ ะะ)
rus_verbs:ะกะะะขะะขะฌะกะฏ{}, // ะพะฝะฐ ะฟะพ-ะฟัะตะถะฝะตะผั ัะฒะตัะธััั ะฝะฐ ะปะธัะฐั
ะปัะดะตะน (ะกะะะขะะขะฌะกะฏ ะะ ะฟัะตะดะป)
rus_verbs:ะะ ะะะะะะะะะขะฌ{}, // ะะปะฐััะธ ะะพัะบะฒั ะฝะฐะผะตัะตะฝั ะพัะณะฐะฝะธะทะพะฒะฐัั ะผะฐัะปะตะฝะธัะฝัะต ะณัะปัะฝะธั ะฝะฐ 100 ะฟะปะพัะฐะดะบะฐั
(ะะ ะะะะะะะะะขะฌ ะะ ะฟัะตะดะป)
rus_verbs:ะะะะขะฌ{}, // ะะผะตั ะฒะปะฐััั ะฝะฐ ะฝะธะทะพะฒะพะผ ััะพะฒะฝะต, ะพะบะฐะทัะฒะฐัั ัะฐะผะพะต ะฝะตะฟะพััะตะดััะฒะตะฝะฝะพะต ะธ ะพะฟัะตะดะตะปัััะตะต ะฒะปะธัะฝะธะต ะฝะฐ ะฒะตัั
ะพะฒะฝัั ะฒะปะฐััั (ะะะะขะฌ ะะ ะฟัะตะดะป)
rus_verbs:ะะะ ะะะะะะขะฌ{}, // ะะฟัะพะฑะพะฒะฐัั ะธ ะพััะพัะธัั ััะพั ะธะฝััััะผะตะฝั ะฝะฐ ะผะตััะฝัั
ะธ ัะตะณะธะพะฝะฐะปัะฝัั
ะฒัะฑะพัะฐั
(ะะะ ะะะะะะขะฌ, ะะขะขะะงะะขะฌ ะะ ะฟัะตะดะป)
rus_verbs:ะะขะขะะงะะขะฌ{},
rus_verbs:ะะะะะะะขะฌ{}, // ะฃัะฐััะฝะธะบะฐะผ ัะพะฒะตัะฐะฝะธั ะฟัะตะดะปะพะถะตะฝะพ ะฟะพะดะณะพัะพะฒะธัั ะฟะพ ััะพะผั ะฒะพะฟัะพัั ัะฒะพะธ ะฟัะตะดะปะพะถะตะฝะธั ะธ ะดะพะปะพะถะธัั ะฝะฐ ะฟะพะฒัะพัะฝะพะน ะฒัััะตัะต (ะะะะะะะขะฌ ะะ ะฟัะตะดะป)
rus_verbs:ะะะ ะะะะะซะะะขะฌะกะฏ{}, // ะกะพะปะตะฒัะต ะธ ะฟัะปะตะฒัะต ะฑััะธ , ะพะฑัะฐะทัััะธะตัั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััะธ ะพะฑะฝะฐะถะตะฝะฝะพะน ะฟะปะพัะฐะดะธ ะผะพัั , ัะฝะธััะพะถะฐัั ััะพะถะฐะธ ะธ ัะฐััะธัะตะปัะฝะพััั (ะะะ ะะะะะซะะะขะฌะกะฏ ะะ)
rus_verbs:ะกะะะ ะะขะฌ{}, // ะธัะฟะพะปัะทัะตั ัะพะฑัะฐะฝะฝัะต ะฝะฐ ะผะตััะฝะพะผ ััะฝะบะต ะดะตะฟะพะทะธัั (ะกะะะ ะะขะฌ ะะ ะฟัะตะดะป)
ะธะฝัะธะฝะธัะธะฒ:ะะะฅะะะะขะฌะกะฏ{ ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะฝะฐั
ะพะดะธะฒัะธั
ัั ะฝะฐ ะฑะพััั ัะฐะผะพะปะตัะฐ (ะะะฅะะะะขะฌะกะฏ ะะ ะฟัะตะดะป)
ะณะปะฐะณะพะป:ะะะฅะะะะขะฌะกะฏ{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐั
ะพะดะธะฒัะธะนัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐั
ะพะดััะธะนัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะฝะฐั
ะพะดััั{},
rus_verbs:ะะะขะะะะขะฌ{}, // ะฟะธัั ะณะพัะพะฒัั ัะฐะผะธ ะฝะฐ ะฟัะธะผััะฐั
(ะะะขะะะะขะฌ ะะ ะฟัะตะดะป)
rus_verbs:ะ ะะะะะขะฌะกะฏ{}, // ะะฝะธ ัะพะพะฑัะธะปะธ ะพ ัะธะปัะฝะพะผ ั
ะปะพะฟะบะต , ะบะพัะพััะน ัะฐะทะดะฐะปัั ะฝะฐ ัะตััะธัะพัะธะธ ะฝะตััะตะฑะฐะทั (ะ ะะะะะขะฌะกะฏ ะะ)
rus_verbs:ะะะะกะะะะฌะะซะะะขะฌะกะฏ{}, // ะฟะพะดัะบะฐะปัะทัะฒะฐัััั ะฝะฐ ัะพะน ะถะต ะฐะฟะตะปััะธะฝะพะฒะพะน ะบะพัะบะต (ะะะะกะะะะฌะะซะะะขะฌะกะฏ ะะ)
rus_verbs:ะกะะ ะซะขะฌะกะฏ{}, // ะะตัะผะฐะฝะธั: ะปะฐัะฒะธะตั ะพะณัะฐะฑะธะป ะผะฐะณะฐะทะธะฝ ะธ ะฟะพะฟััะฐะปัั ัะบัััััั ะฝะฐ ัะฐะบัะธ (ะกะะ ะซะขะฌะกะฏ ะะ ะฟัะตะดะป)
rus_verbs:ะะซะ ะะกะขะะขะฌ{}, // ะะฐัะธะตะฝัั ะฒััะฐััะธะปะธ ะฝะพะฒัะน ะฝะพั ะฝะฐ ััะบะต (ะะซะ ะะกะขะะขะฌ ะะ)
rus_verbs:ะะ ะะะะะะะกะขะ ะะ ะะะะขะฌ{}, // ะะฝะธ ั
ะพััั ะฟะพะดัะตัะบะฝััั ัะผะพัะธะพะฝะฐะปัะฝัั ัะพะฝะบะพััั ะพะฟะฟะพะทะธัะธะพะฝะตัะฐ ะธ ะฝะฐ ััะพะผ ัะพะฝะต ะฟัะพะดะตะผะพะฝัััะธัะพะฒะฐัั ะฑะตะทะดััะฝะพััั ัะพััะธะนัะบะพะน ะฒะปะฐััะธ (ะะ ะะะะะะะกะขะ ะะ ะะะะขะฌ ะะ ะฟัะตะดะป)
rus_verbs:ะะกะฃะฉะะกะขะะะฏะขะฌะกะฏ{}, // ะฟะตัะฒะธัะฝัะน ะฐะฝะฐะปะธะท ัะผะตัะธ ะทะฐะฟะฐั
ะพะฒ ะผะพะถะตั ะพัััะตััะฒะปััััั ัะถะต ะฝะฐ ััะพะฒะฝะต ัะตัะตะฟัะพัะฝัั
ะฝะตะนัะพะฝะพะฒ ะฑะปะฐะณะพะดะฐัั ะผะตั
ะฐะฝะธะทะผั ะปะฐัะตัะฐะปัะฝะพะณะพ ัะพัะผะพะถะตะฝะธั (ะะกะฃะฉะะกะขะะะฏะขะฌะกะฏ ะะ)
rus_verbs:ะะซะะะะฏะขะฌะกะฏ{}, // ะฏะณะพะดั ะฑัััะฝะธะบะธ, ัะตะทะบะพ ะฒัะดะตะปัััะธะตัั ัะฒะพะธะผ ะบัะฐัะฝัะผ ัะฒะตัะพะผ ะฝะฐ ัะพะฝะต ะทะตะปัะฝะพะน ะปะธััะฒั, ะฟะพะตะดะฐัััั ะถะธะฒะพัะฝัะผะธ ะธ ะฟัะธัะฐะผะธ (ะะซะะะะฏะขะฌะกะฏ ะะ)
rus_verbs:ะ ะะกะะ ะซะขะฌ{}, // ะะฐ ะฃะบัะฐะธะฝะต ัะฐัะบัััะพ ะบััะฟะฝะพะต ะผะพัะตะฝะฝะธัะตััะฒะพ ะฒ ััะตัะต ัััะธะทะผะฐ (ะ ะะกะะ ะซะขะฌ ะะ)
rus_verbs:ะะะะะ ะะะะขะฌะกะฏ{}, // ะะผะปะตั ะพะฑะถะฐัะธะฒะฐะตััั ะฝะฐ ัะปะธะฒะพัะฝะพะผ ะผะฐัะปะต ั ะพะดะฝะพะน ััะพัะพะฝั, ะฟะพะบะฐ ะพะฝ ะฟะพััะธ ะฟะพะปะฝะพัััั ะฝะต ะทะฐะณัััะตะตั (ะะะะะ ะะะะขะฌะกะฏ ะะ)
rus_verbs:ะะ ะะะะขะะะะฏะขะฌ{}, // ะฏะธัะฝะธัะฐ โ ะฑะปัะดะพ ะตะฒัะพะฟะตะนัะบะพะน ะบัั
ะฝะธ, ะฟัะธะณะพัะพะฒะปัะตะผะพะต ะฝะฐ ัะบะพะฒะพัะพะดะต ะธะท ัะฐะทะฑะธััั
ัะธั (ะะ ะะะะขะะะะฏะขะฌ ะะ)
rus_verbs:ะ ะะกะกะะะะขะฌ{}, // ะะตะฝัะบะฐ ัะฐััะฐะดะธะป ะธะณัััะบะธ ะฝะฐ ัะบะฐะผะตะตัะบะต (ะ ะะกะกะะะะขะฌ ะะ)
rus_verbs:ะะะะะะะขะฌ{}, // ะพะฑะพะถะดะธ ะะฝะถะตะปั ะฝะฐ ะพััะฐะฝะพะฒะบะต ััะพะปะปะตะนะฑััะฐ (ะะะะะะะขะฌ ะะ)
rus_verbs:ะฃะงะะขะฌะกะฏ{}, // ะะฐัะธะฝะฐ ััะธััั ะฝะฐ ัะฐะบัะปััะตัะต ะถััะฝะฐะปะธััะธะบะธ (ะฃะงะะขะฌะกะฏ ะะ ะฟัะตะดะป)
rus_verbs:ัะฐัะบะปะฐะดัะฒะฐัััั{}, // ะกะพะทัะตะฒัะธะต ัะตะผะตะฝะฝัะต ัะบะทะตะผะฟะปััั ัะฐัะบะปะฐะดัะฒะฐัั ะฝะฐ ัะพะปะฝัะต ะธะปะธ ะฒ ัะตะฟะปะพะผ ะผะตััะต, ะณะดะต ะพะฝะธ ะดะตะปะฐัััั ะผัะณะบะธะผะธ (ะ ะะกะะะะะซะะะขะฌะกะฏ ะ, ะะ)
rus_verbs:ะะะกะะฃะจะะขะฌ{}, // ะะพัะปััะฐะนัะต ะดััะทะตะน ะธ ะฒัะฐะณะพะฒ ะฝะฐ ัะฐัััะพัะฝะธะธ! (ะะะกะะฃะจะะขะฌ ะะ)
rus_verbs:ะะะกะขะะกะฌ{}, // ะะฐ ััะพัะพะฝะต ะฟัะพัะธะฒะฝะธะบะฐ ะฒัั ะฝะพัั ะฒะตะปะฐัั ะฟะตัะตะณััะฟะฟะธัะพะฒะบะฐ ัะธะป. (ะะะกะขะะกะฌ ะะ)
rus_verbs:ะะะะะขะะ ะะกะะะะขะฌะกะฏ{}, // ะบะพััะตัะฟะพะฝะดะตะฝั ะฟะพะธะฝัะตัะตัะพะฒะฐะปัั ั ะปัะดะตะน ะฝะฐ ัะปะธัะต (ะะะะะขะะ ะะกะะะะขะฌะกะฏ ะะ)
rus_verbs:ะะขะะ ะซะะะขะฌะกะฏ{}, // ะ ะพััะธะนัะบะธะต ะฑะธัะถะธ ะพัะบััะฒะฐัััั ะฝะฐ ะฝะตะณะฐัะธะฒะฝะพะผ ัะพะฝะต (ะะขะะ ะซะะะขะฌะกะฏ ะะ)
rus_verbs:ะกะฅะะะะขะฌ{}, // ะั ัั
ะพะดะธัะต ะฝะฐ ัะปะตะดัััะตะน ะพััะฐะฝะพะฒะบะต? (ะกะฅะะะะขะฌ ะะ)
rus_verbs:ะะะะะะะฃะขะฌ{}, // ะั ะพัะตั ะฟะพะณะธะฑ ะฝะฐ ะฒะพะนะฝะต. (ะะะะะะะฃะขะฌ ะะ)
rus_verbs:ะะซะะขะ{}, // ะะฝะธะณะฐ ะฒัะนะดะตั ะฝะฐ ะฑัะดััะตะน ะฝะตะดะตะปะต. (ะะซะะขะ ะะ ะฟัะตะดะป)
rus_verbs:ะะะกะขะะกะฌ{}, // ะะพัะฐะฑะปั ะฝะตััััั ะฝะฐ ะฒัะตั
ะฟะฐัััะฐั
. (ะะะกะขะะกะฌ ะะ ะฟัะตะดะป)
rus_verbs:ะฒะบะฐะปัะฒะฐัั{}, // ะะฐะฟะฐ ะฒะบะฐะปัะฒะฐะตั ะฝะฐ ัะฐะฑะพัะต, ััะพะฑั ะฟัะพะบะพัะผะธัั ัะตะผัั (ะฒะบะฐะปัะฒะฐัั ะฝะฐ)
rus_verbs:ะดะพะบะฐะทะฐัั{}, // ัะฐะทัะฐะฑะพััะธะบะธ ะดะพะบะฐะทะฐะปะธ ะฝะฐ ะฟัะฐะบัะธะบะต ะฟัะธะผะตะฝะธะผะพััั ะดะฐะฝะฝะพะณะพ ะฟะพะดั
ะพะดะฐ ะบ ะพะฑััะตัั ััะตะฝ (ะดะพะบะฐะทะฐัั ะฝะฐ, ะฟัะธะผะตะฝะธะผะพััั ะบ)
rus_verbs:ั
ัะปะธะณะฐะฝะธัั{}, // ะดะพะทะฒะพะปััั ะบะพะผั-ัะพ ั
ัะปะธะณะฐะฝะธัั ะฝะฐ ะบะปะฐะดะฑะธัะต (ั
ัะปะธะณะฐะฝะธัั ะฝะฐ)
ะณะปะฐะณะพะป:ะฒััะธัะฐัั{ะฒะธะด:ัะพะฒะตัั}, ะธะฝัะธะฝะธัะธะฒ:ะฒััะธัะฐัั{ะฒะธะด:ัะพะฒะตัั}, // ะฒััะธัะฐัั ะฝะฐ ัะฐะนัะต (ะฒััะธัะฐัั ะฝะฐ ัะฐะนัะต)
ะดะตะตะฟัะธัะฐััะธะต:ะฒััะธัะฐะฒ{},
rus_verbs:ะฐะบะบะพะผะฟะฐะฝะธัะพะฒะฐัั{}, // ะพะฝ ะฐะบะบะพะผะฟะฐะฝะธัะพะฒะฐะป ะฟะตะฒัั ะฝะฐ ะณัะฑะฝะพะน ะณะฐัะผะพัะบะต (ะฐะบะบะพะผะฟะฐะฝะธัะพะฒะฐัั ะฝะฐ)
rus_verbs:ะฝะฐะฑัะฐัั{}, // ััะฐััั ั ะทะฐะณะพะปะพะฒะบะพะผ, ะฝะฐะฑัะฐะฝะฝัะผ ะฝะฐ ะบะพะผะฟัััะตัะต
rus_verbs:ัะดะตะปะฐัั{}, // ะบะฝะธะณะฐ ั ะธะปะปััััะฐัะธะตะน, ัะดะตะปะฐะฝะฝะพะน ะฝะฐ ะบะพะผะฟัััะตัะต
rus_verbs:ัะฐะทะฒะฐะปะธัััั{}, // ะะฝัะพะฝะธะพ ัะฐะทะฒะฐะปะธะปัั ะฝะฐ ะดะธะฒะฐะฝะต
rus_verbs:ัะปะตัััั{}, // ะะฝัะพะฝะธะพ ัะปะตะณัั ะฝะฐ ะฟะพะปั
rus_verbs:ะทะฐััะฑะธัั{}, // ะะฐััะฑะธ ัะตะฑะต ะฝะฐ ะฝะพัั.
rus_verbs:ัะตะฝะธัั{}, // ะะณะพ ัะตะฝัั ะฝะฐ ะทะฐะฒะพะดะต.
rus_verbs:ะฒะตัะฝััััั{}, // ะัะตั ะฒะตัะฝัะปัั ะฝะฐ ะทะฐะบะฐัะต.
rus_verbs:ัะธัั{}, // ะั ัะผะตะตัะต ัะธัั ะฝะฐ ะผะฐัะธะฝะบะต?
rus_verbs:ะฑะธัั{}, // ะกะบะพั ะฑััั ะฝะฐ ะฑะพะนะฝะต.
rus_verbs:ะฒัะตั
ะฐัั{}, // ะั ะฒัะตั
ะฐะปะธ ะฝะฐ ัะฐััะฒะตัะต.
rus_verbs:ะฒะฐะปััััั{}, // ะะฐ ะฟะพะปั ะฒะฐะปัะตััั ะฑัะผะฐะณะฐ.
rus_verbs:ัะฐะทะปะพะถะธัั{}, // ะพะฝะฐ ัะฐะทะปะพะถะธะปะฐ ะฟะพะปะพัะตะฝัะต ะฝะฐ ะฟะตัะบะต
rus_verbs:ะทะฐะฝะธะผะฐัััั{}, // ั ะทะฐะฝะธะผะฐััั ะฝะฐ ััะตะฝะฐะถะตัะต
rus_verbs:ะฟะพะทะฐะฝะธะผะฐัััั{},
rus_verbs:ะฟะพัั
ะฐัั{}, // ะฟะพัั
ะฐัั ะฝะฐ ะปัะณั
rus_verbs:ะฟัะตัะตะบะฐัั{}, // ะฟัะตัะตะบะฐัั ะฝะฐ ะบะพัะฝั
rus_verbs:ะธะทัััะฝััััั{}, // ะธะทัััะฝััััั ะฝะฐ ะฝะตะฟะพะฝััะฝะพะผ ัะทัะบะต
rus_verbs:ัะฐะทะฒะตัะธัั{}, // ัะฐะทะฒะตัะธัั ะฝะฐ ััะพะปะฑะฐั
rus_verbs:ะพะฑัะฐััะธ{}, // ะพะฑัะฐััะธ ะฝะฐ ัะถะฝะพะน ัะฐััะธ
rus_verbs:ะพัะบะปะฐะดัะฒะฐัััั{}, // ะพัะบะปะฐะดัะฒะฐัััั ะฝะฐ ััะตะฝะบะฐั
ะฐััะตัะธะน
rus_verbs:ัะฝะพัะธัั{}, // ัะฝะพัะธัั ะฝะฐ ะฝะพัะธะปะบะฐั
rus_verbs:ะฟัะพะฟะปััั{}, // ะฟัะพะฟะปััั ะฝะฐ ะฟะปะพัั
rus_verbs:ะฟะพะดัะตะทะถะฐัั{}, // ะฟะพะดัะตะทะถะฐัั ะฝะฐ ะฟะพะฒะพะทะบะฐั
rus_verbs:ะฟัะปััะธัะพะฒะฐัั{}, // ะฟัะปััะธัะพะฒะฐัั ะฝะฐ ะปะฑั
rus_verbs:ัะฐััะตััััั{}, // ะฟัะธัั ัะฐััะตะปะธัั ะฝะฐ ะฒะตัะบะฐั
rus_verbs:ะทะฐััะพะฟะพัะธัััั{}, // ะทะฐััะพะฟะพัะธัััั ะฝะฐ ะฟะตัะฒะพะผ ะฟัะฝะบัะต
rus_verbs:ะธะทะปะพะฒะธัั{}, // ะธะทะปะพะฒะธัั ะฝะฐ ะพะบัะฐะธะฝะฐั
rus_verbs:ะฟะพะบะฐัะฐัััั{}, // ะฟะพะบะฐัะฐัััั ะฝะฐ ะผะฐัะธะฝะบะฐั
rus_verbs:ะทะฐะปะพะฟะพัะฐัั{}, // ะทะฐะปะพะฟะพัะฐัั ะฝะฐ ะฝะตะธะทะฒะตััะฝะพะผ ัะทัะบะต
rus_verbs:ัะฐัััะณะธะฒะฐัั{}, // ัะฐัััะณะธะฒะฐัั ะฝะฐ ััะฐะฝะบะต
rus_verbs:ะฟะพะดะตะปัะฒะฐัั{}, // ะฟะพะดะตะปัะฒะฐัั ะฝะฐ ะฟะปัะถะต
rus_verbs:ะฟะพะดััะตัะตัั{}, // ะฟะพะดััะตัะตัั ะฝะฐ ะฟะปะพัะฐะดะบะต
rus_verbs:ะฟัะพะตะบัะธัะพะฒะฐัั{}, // ะฟัะพะตะบัะธัะพะฒะฐัั ะฝะฐ ะบะพะผะฟัััะตัะต
rus_verbs:ะฟัะธััะปะธัััั{}, // ะฟัะธััะปะธัััั ะฝะฐ ะบััะตัะบะต
rus_verbs:ะดะพะทะฒะพะปััั{}, // ะดะพะทะฒะพะปััั ะบะพะผั-ัะพ ั
ัะปะธะณะฐะฝะธัั ะฝะฐ ะบะปะฐะดะฑะธัะต
rus_verbs:ะฟะพัััะตะปััั{}, // ะฟะพัััะตะปััั ะฝะฐ ะธัะฟััะฐัะตะปัะฝะพะผ ะฟะพะปะธะณะพะฝะต
rus_verbs:ะทะฐัะธะถะธะฒะฐัััั{}, // ะทะฐัะธะถะธะฒะฐัััั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ะฝะตะถะธัััั{}, // ะฝะตะถะธัััั ะฝะฐ ัะพะปะฝััะบะต
rus_verbs:ะฟัะธัะพะผะธัััั{}, // ะฟัะธัะพะผะธัััั ะฝะฐ ัะฐะฑะพัะตะผ ะผะตััะต
rus_verbs:ะฟะพัะตะปััััั{}, // ะฟะพัะตะปััััั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะฟะพััะณะธะฒะฐัััั{}, // ะฟะพััะณะธะฒะฐัััั ะฝะฐ ะทะตะผะปะต
rus_verbs:ะพัะปะตะถะธะฒะฐัััั{}, // ะพัะปะตะถะธะฒะฐัััั ะฝะฐ ะบะพะนะบะต
rus_verbs:ะฟัะพัะฐัะฐะฝะธัั{}, // ะฟัะพัะฐัะฐะฝะธัั ะฝะฐ ัะฐะฝะบะต
rus_verbs:ะณะฐััะตะฒะฐัั{}, // ะณะฐััะตะฒะฐัั ะฝะฐ ะบะพะฝะต
rus_verbs:ะพะฑะปัะฟะธัััั{}, // ะพะฑะปัะฟะธัััั ะฝะฐ ะฝะพัั
rus_verbs:ะพะณะพะฒะพัะธัั{}, // ะพะณะพะฒะพัะธัั ะฝะฐ ัะพะฑะตัะตะดะพะฒะฐะฝะธะธ
rus_verbs:ะทะฐัะตะณะธัััะธัะพะฒะฐัััั{}, // ะทะฐัะตะณะธัััะธัะพะฒะฐัััั ะฝะฐ ัะฐะนัะต
rus_verbs:ะพัะฟะตัะฐัะฐัั{}, // ะพัะฟะตัะฐัะฐัั ะฝะฐ ะบะฐััะพะฝะต
rus_verbs:ััะบะพะฝะพะผะธัั{}, // ััะบะพะฝะพะผะธัั ะฝะฐ ะผะตะปะพัะฐั
rus_verbs:ะฟะพะบะฐัะฐัั{}, // ะฟะพะบะฐัะฐัั ะฝะฐ ะฟะพะฝะธ
rus_verbs:ะบะพะปะตัะธัั{}, // ะบะพะปะตัะธัั ะฝะฐ ััะฐัะพะน ะผะฐัะธะฝะต
rus_verbs:ะฟะพะฝะฐัััะพะธัั{}, // ะฟะพะฝะฐัััะพะธัั ะฝะฐ ััะฐััะบะฐั
rus_verbs:ะฟะพะดะถะฐัะธัั{}, // ะฟะพะดะถะฐัะธัั ะฝะฐ ะบะพัััะต
rus_verbs:ัะทะฝะฐะฒะฐัััั{}, // ัะทะฝะฐะฒะฐัััั ะฝะฐ ัะพัะพะณัะฐัะธะธ
rus_verbs:ะพัะพัะฐัั{}, // ะพัะพัะฐัั ะฝะฐ ะบะฐะทะตะฝะฝัั
ั
ะฐััะฐั
rus_verbs:ัะตะดะตัั{}, // ัะตะดะตัั ะฝะฐ ะผะฐะบััะบะต
rus_verbs:ะพะณะปะฐัะฐัั{}, // ะพะณะปะฐัะฐัั ะฝะฐ ะพะฑัะตะผ ัะพะฑัะฐะฝะธะธ
rus_verbs:ะปะพะฟะพัะฐัั{}, // ะปะพะฟะพัะฐัั ะฝะฐ ะธะฒัะธัะต
rus_verbs:ะฟัะธะณัะตัั{}, // ะฟัะธะณัะตัั ะฝะฐ ะณััะดะธ
rus_verbs:ะบะพะฝััะปััะธัะพะฒะฐัััั{}, // ะบะพะฝััะปััะธัะพะฒะฐัััั ะฝะฐ ัะพััะผะต
rus_verbs:ะฟัะธะฝะพัะธัััั{}, // ะฟัะธะฝะพัะธัััั ะฝะฐ ะพะดะตะถะดะต
rus_verbs:ัััะธัััั{}, // ัััะธัััั ะฝะฐ ะฑะฐะปะบะพะฝะต
rus_verbs:ะฝะฐัะปะตะดะธัั{}, // ะฝะฐัะปะตะดะธัั ะฝะฐ ะฟะพะปั
rus_verbs:ะฝะฐะณัะตัััั{}, // ะฝะฐะณัะตัััั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ััะฑะฐัะธัั{}, // ััะฑะฐัะธัั ะฝะฐ ะพะทะตัะต
rus_verbs:ะฟัะพะบะฐัะธัั{}, // ะฟัะพะบะฐัะธัั ะฝะฐ ะฒัะฑะพัะฐั
rus_verbs:ะทะฐะฟะธะฝะฐัััั{}, // ะทะฐะฟะธะฝะฐัััั ะฝะฐ ัะพะฒะฝะพะผ ะผะตััะต
rus_verbs:ะพัััะฑะธัััั{}, // ะพัััะฑะธัััั ะฝะฐ ะผัะณะบะพะน ะฟะพะดััะบะต
rus_verbs:ะทะฐะผะพัะพะทะธัั{}, // ะทะฐะผะพัะพะทะธัั ะฝะฐ ัะปะธัะต
rus_verbs:ะฟัะพะผะตัะทะฝััั{}, // ะฟัะพะผะตัะทะฝััั ะฝะฐ ะพัะบัััะพะผ ะฒะพะทะดัั
ะต
rus_verbs:ะฟัะพัะพั
ะฝััั{}, // ะฟัะพัะพั
ะฝััั ะฝะฐ ะฑะฐัะฐัะตะต
rus_verbs:ัะฐะทะฒะพะทะธัั{}, // ัะฐะทะฒะพะทะธัั ะฝะฐ ะฒะตะปะพัะธะฟะตะดะต
rus_verbs:ะฟัะธะบะพัะฝััั{}, // ะฟัะธะบะพัะฝััั ะฝะฐ ะดะธะฒะฐะฝัะธะบะต
rus_verbs:ะพัะฟะตัะฐัะฐัััั{}, // ะพัะฟะตัะฐัะฐัััั ะฝะฐ ะบะพะถะต
rus_verbs:ะฒััะฒะปััั{}, // ะฒััะฒะปััั ะฝะฐ ัะฐะผะพะถะฝะต
rus_verbs:ัะฐัััะฐะฒะปััั{}, // ัะฐัััะฐะฒะปััั ะฝะฐ ะฑะฐัะฝัั
rus_verbs:ะฟัะพะบัััะธัั{}, // ะฟัะพะบัััะธัั ะฝะฐ ะฟะฐะปััะต
rus_verbs:ัะผัะฒะฐัััั{}, // ัะผัะฒะฐัััั ะฝะฐ ัะปะธัะต
rus_verbs:ะฟะตัะตัะบะฐะทัะฒะฐัั{}, // ะฟะตัะตัะบะฐะทัะฒะฐัั ะฝะฐ ัััะฐะฝะธัะฐั
ัะพะผะฐะฝะฐ
rus_verbs:ัะดะฐะปััั{}, // ัะดะฐะปััั ะฝะฐ ะฟัั
ะพะฒะธะบะต
rus_verbs:ั
ะพะทัะนะฝะธัะฐัั{}, // ั
ะพะทัะนะฝะธัะฐัั ะฝะฐ ัะบะปะฐะดะต
rus_verbs:ะพะฟะตัะธัะพะฒะฐัั{}, // ะพะฟะตัะธัะพะฒะฐัั ะฝะฐ ะฟะพะปะต ะฑะพั
rus_verbs:ะฟะพะฝะพัะธัั{}, // ะฟะพะฝะพัะธัั ะฝะฐ ะณะพะปะพะฒะต
rus_verbs:ะทะฐะผััะปัะบะฐัั{}, // ะทะฐะผััะปัะบะฐัั ะฝะฐ ะบะพะปะตะฝัั
rus_verbs:ะฟะตัะตะดะฒะธะณะฐัั{}, // ะฟะตัะตะดะฒะธะณะฐัั ะฝะฐ ัะตะปะตะถะบะต
rus_verbs:ะฟัะพัะตััะธัั{}, // ะฟัะพัะตััะธัั ะฝะฐ ะทะตะผะปะต
rus_verbs:ะบะพะปะดะพะฒะฐัั{}, // ะบะพะปะดะพะฒะฐัั ะฝะฐ ะบัั
ะฝะต
rus_verbs:ะพัะฒะพะทะธัั{}, // ะพัะฒะพะทะธัั ะฝะฐ ะบะฐะทะตะฝะฝะพะผ ััะฐะฝัะฟะพััะต
rus_verbs:ััะฐั
ะฐัั{}, // ััะฐั
ะฐัั ะฝะฐ ะฟัะธัะพะดะต
rus_verbs:ะผะฐััะตัะธัั{}, // ะผะฐััะตัะธัั ะฝะฐ ะบัั
ะฝะต
rus_verbs:ัะตะผะพะฝัะธัะพะฒะฐัั{}, // ัะตะผะพะฝัะธัะพะฒะฐัั ะฝะฐ ะบะพะปะตะฝะบะต
rus_verbs:ัะฐะทะฒะตะทัะธ{}, // ัะฐะทะฒะตะทัะธ ะฝะฐ ะฒะตะปะพัะธะฟะตะดะต
rus_verbs:ัะพะฑะตัั{}, // ัะพะฑะตัั ะฝะฐ ััะตะฝะต
ะธะฝัะธะฝะธัะธะฒ:ัะตะฐะปะธะทะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ัะตะฐะปะธะทะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะตะฐะปะธะทะพะฒะฐัั ะฝะฐ ัะฐะนัะต
ะณะปะฐะณะพะป:ัะตะฐะปะธะทะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะตะฐะปะธะทะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ัะตะฐะปะธะทะพะฒะฐะฒ{}, ะดะตะตะฟัะธัะฐััะธะต:ัะตะฐะปะธะทัั{},
rus_verbs:ะฟะพะบะฐััััั{}, // ะฟะพะบะฐััััั ะฝะฐ ัะผะตััะฝะพะผ ะพะดัะต
rus_verbs:ัะฟะตัะธะฐะปะธะทะธัะพะฒะฐัััั{}, // ัะฟะตัะธะฐะปะธะทะธัะพะฒะฐัััั ะฝะฐ ัะตััะธัะพะฒะฐะฝะธะธ
rus_verbs:ะฟะพะฟััะณะฐัั{}, // ะฟะพะฟััะณะฐัั ะฝะฐ ะฑะฐัััะต
rus_verbs:ะฟะตัะตะฟะธััะฒะฐัั{}, // ะฟะตัะตะฟะธััะฒะฐัั ะฝะฐ ััะพะปะต
rus_verbs:ัะฐัะฟะธััะฒะฐัั{}, // ัะฐัะฟะธััะฒะฐัั ะฝะฐ ะดะพัะบะต
rus_verbs:ะทะฐะถะธะผะฐัั{}, // ะทะฐะถะธะผะฐัั ะฝะฐ ะทะฐะฟััััะต
rus_verbs:ะฟัะฐะบัะธะบะพะฒะฐัััั{}, // ะฟัะฐะบัะธะบะพะฒะฐัััั ะฝะฐ ะผััะฐั
rus_verbs:ัะตะดะธะฝะธัััั{}, // ัะตะดะธะฝะธัััั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะฟะพะดะพั
ะฝััั{}, // ะฟะพะดะพั
ะฝััั ะฝะฐ ััะถะฑะธะฝะต
rus_verbs:ะฟัะธะฟะพะดะฝะธะผะฐัััั{}, // ะฟัะธะฟะพะดะฝะธะผะฐัััั ะฝะฐ ััะบะฐั
rus_verbs:ััะพะดะธัััั{}, // ััะพะดะธัััั ะฝะฐ ะฟะพะปัั
rus_verbs:ะฟัะพะดะพะปะถะธัััั{}, // ะฟัะพะดะพะปะถะธัััั ะฝะฐ ัะปะธัะต
rus_verbs:ะฟะพัะฐะฟัะฒะฐัั{}, // ะฟะพัะฐะฟัะฒะฐัั ะฝะฐ ะดะธะฒะฐะฝะต
rus_verbs:ะพะฑะพะดัะฐัั{}, // ะพะฑะพะดัะฐัั ะฝะฐ ัะฟะธะฝะต
rus_verbs:ัะบัััะธัััั{}, // ัะบัััะธัััั ะฝะฐ ะฟะตัะบะต
rus_verbs:ัะพัะผะพะทะฝััั{}, // ัะพัะผะพะทะฝััั ะฝะฐ ะฟะตัะตะบัะตััะบะต
rus_verbs:ะปััะพะฒะฐัั{}, // ะปััะพะฒะฐัั ะฝะฐ ั
ััะพัะต
rus_verbs:ะทะฐัะตะณะธัััะธัะพะฒะฐัั{}, // ะทะฐัะตะณะธัััะธัะพะฒะฐัั ะฝะฐ ัะฐะนัะต
rus_verbs:ะฟะตัะตะถะดะฐัั{}, // ะฟะตัะตะถะดะฐัั ะฝะฐ ะฒะตััะธะฝะต ั
ะพะปะผะฐ
rus_verbs:ะดะพะผะธะฝะธัะพะฒะฐัั{}, // ะดะพะผะธะฝะธัะพะฒะฐัั ะฝะฐ ัะตััะธัะพัะธะธ
rus_verbs:ะฟัะฑะปะธะบะพะฒะฐัั{}, // ะฟัะฑะปะธะบะพะฒะฐัั ะฝะฐ ัะฐะนัะต
rus_verbs:ะผะพััะธัั{}, // ะผะพััะธัั ะฝะฐ ะปะฑั
rus_verbs:ัะบะพะฝัะตะฝััะธัะพะฒะฐัััั{}, // ัะบะพะฝัะตะฝััะธัะพะฒะฐัััั ะฝะฐ ะณะปะฐะฒะฝะพะผ
rus_verbs:ะฟะพะดัะฐะฑะฐััะฒะฐัั{}, // ะฟะพะดัะฐะฑะฐััะฒะฐัั ะฝะฐ ััะฝะบะต
rus_verbs:ัะตะฟะตัะธัะพะฒะฐัั{}, // ัะตะฟะตัะธัะพะฒะฐัั ะฝะฐ ะทะฐะดะฝะตะผ ะดะฒะพัะต
rus_verbs:ะฟะพะดะฒะตัะฝััั{}, // ะฟะพะดะฒะตัะฝััั ะฝะฐ ะฑััััะฐัะบะต
rus_verbs:ะทะฐัะตะปะตััะตัั{}, // ะทะฐัะตะปะตััะตัั ะฝะฐ ะฒะตััั
rus_verbs:ัะฐััะตััะฒะฐัั{}, // ัะฐััะตััะฒะฐัั ะฝะฐ ัะฟะธะฝะต
rus_verbs:ะพะดะตะฒะฐัั{}, // ะพะดะตะฒะฐัั ะฝะฐ ััะฝะบะต
rus_verbs:ะธัะฟะตัั{}, // ะธัะฟะตัั ะฝะฐ ัะณะปัั
rus_verbs:ัะฑัะธัั{}, // ัะฑัะธัั ะฝะฐ ะทะฐััะปะบะต
rus_verbs:ัะพะณัะตัััั{}, // ัะพะณัะตัััั ะฝะฐ ะฟะตัะบะต
rus_verbs:ะทะฐะผะฐััะธัั{}, // ะทะฐะผะฐััะธัั ะฝะฐ ะณะพัะธะทะพะฝัะต
rus_verbs:ะฟะตัะตััะธััะฒะฐัั{}, // ะฟะตัะตััะธััะฒะฐัั ะฝะฐ ะฟะฐะปััะฐั
rus_verbs:ะณะฐะปะดะตัั{}, // ะณะฐะปะดะตัั ะฝะฐ ะบััะปััะต
rus_verbs:ะฟะตัะตะฟะปััั{}, // ะฟะตัะตะฟะปััั ะฝะฐ ะฟะปะพัั
rus_verbs:ะฟะตัะตะดะพั
ะฝััั{}, // ะฟะตัะตะดะพั
ะฝััั ะฝะฐ ัะบะฐะผะตะนะบะต
rus_verbs:ะฟัะธะถะธัััั{}, // ะฟัะธะถะธัััั ะฝะฐ ัะตัะผะต
rus_verbs:ะฟะตัะตะฟัะฐะฒะปััััั{}, // ะฟะตัะตะฟัะฐะฒะปััััั ะฝะฐ ะฟะปะพัะฐั
rus_verbs:ะฝะฐะบัะฟะธัั{}, // ะฝะฐะบัะฟะธัั ะฝะฐ ะฑะปะพัะธะฝะพะผ ััะฝะบะต
rus_verbs:ะฟัะพัะพััะฐัั{}, // ะฟัะพัะพััะฐัั ะฝะฐ ะฒะธะดั
rus_verbs:ะผะพะบะฝััั{}, // ะผะพะบะฝััั ะฝะฐ ัะปะธัะต
rus_verbs:ะทะฐัััะบะฐัั{}, // ะทะฐัััะบะฐัั ะฝะฐ ะบะฐะผะฑัะทะต
rus_verbs:ะทะฐะฒัะทัะฒะฐัั{}, // ะทะฐะฒัะทัะฒะฐัั ะฝะฐ ะฑะพัะธะฝะบะฐั
rus_verbs:ะฟะพะฒะธัะฐัั{}, // ะฟะพะฒะธัะฐัั ะฝะฐ ะฒะตัะบะต
rus_verbs:ะฟะพะดะฒะธะทะฐัััั{}, // ะฟะพะดะฒะธะทะฐัััั ะฝะฐ ะณะพััะดะฐัััะฒะตะฝะฝะพะน ัะปัะถะฑะต
rus_verbs:ะบะพัะผะธัััั{}, // ะบะพัะผะธัััั ะฝะฐ ะฑะพะปะพัะต
rus_verbs:ะฟะพะบััะธัั{}, // ะฟะพะบััะธัั ะฝะฐ ัะปะธัะต
rus_verbs:ะทะธะผะพะฒะฐัั{}, // ะทะธะผะพะฒะฐัั ะฝะฐ ะฑะพะปะพัะฐั
rus_verbs:ะทะฐััะตะณะธะฒะฐัั{}, // ะทะฐััะตะณะธะฒะฐัั ะฝะฐ ะณะธะผะฝะฐััะตัะบะต
rus_verbs:ะฟะพะธะณััะฒะฐัั{}, // ะฟะพะธะณััะฒะฐัั ะฝะฐ ะณะธัะฐัะต
rus_verbs:ะฟะพะณะพัะตัั{}, // ะฟะพะณะพัะตัั ะฝะฐ ะผะฐั
ะธะฝะฐัะธัั
ั ะทะตะผะปะตะน
rus_verbs:ะบัะฒััะบะฐัััั{}, // ะบัะฒััะบะฐัััั ะฝะฐ ะฑะฐัััะต
rus_verbs:ะฟะพั
ัะฐะฟัะฒะฐัั{}, // ะฟะพั
ัะฐะฟัะฒะฐัั ะฝะฐ ะดะธะฒะฐะฝะต
rus_verbs:ะฟัะธะณัะตะฒะฐัั{}, // ะฟัะธะณัะตะฒะฐัั ะฝะฐ ะณััะดะธ
rus_verbs:ะทะฐะฒัะทะฝััั{}, // ะทะฐะฒัะทะฝััั ะฝะฐ ะฑะพะปะพัะต
rus_verbs:ัะฐััะฐัั{}, // ัะฐััะฐัั ะฝะฐ ะฒัะพัะพะผ ััะฐะถะต
rus_verbs:ะทะฐะฝะพัะตะฒะฐัั{}, // ะทะฐะฝะพัะตะฒะฐัั ะฝะฐ ัะตะฝะพะฒะฐะปะต
rus_verbs:ะพััะธะถะธะฒะฐัััั{}, // ะพััะธะถะธะฒะฐัััั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะผัะฐัั{}, // ะผัะฐัั ะฝะฐ ะฑะฐะนะบะต
rus_verbs:ัะณะฝะธัั{}, // ัะณะฝะธัั ะฝะฐ ััะฐะฝะพะฒัั
ััะดะฝะธะบะฐั
rus_verbs:ััะตะฝะธัะพะฒะฐัั{}, // ััะตะฝะธัะพะฒะฐัั ะฝะฐ ะผะฐะฝะตะบะตะฝะฐั
rus_verbs:ะฟะพะฒะตัะตะปะธัััั{}, // ะฟะพะฒะตัะตะปะธัััั ะฝะฐ ะฟัะฐะทะดะฝะธะบะต
rus_verbs:ะธะทะผััะธัััั{}, // ะธะทะผััะธัััั ะฝะฐ ะฑะพะปะพัะต
rus_verbs:ัะฒัะฝััั{}, // ัะฒัะฝััั ะฝะฐ ะฟะพะดะพะบะพะฝะฝะธะบะต
rus_verbs:ัะฐัะบัััะธัั{}, // ัะฐัะบัััะธัั ะฝะฐ ะพัะธ
rus_verbs:ะฒััะฒะตััะธ{}, // ะฒััะฒะตััะธ ะฝะฐ ัะพะปะฝะตัะฝะพะผ ัะฒะตัั
rus_verbs:ะธะทะณะพัะพะฒะปััั{}, // ะธะทะณะพัะพะฒะปััั ะฝะฐ ะบะพะปะตะฝะบะต
rus_verbs:ะณะฝะตะทะดะธัััั{}, // ะณะฝะตะทะดะธัััั ะฝะฐ ะฒะตััะธะฝะต ะดะตัะตะฒะฐ
rus_verbs:ัะฐะทะพะณะฝะฐัััั{}, // ัะฐะทะพะณะฝะฐัััั ะฝะฐ ะผะพัะพัะธะบะปะต
rus_verbs:ะธะทะปะฐะณะฐัััั{}, // ะธะทะปะฐะณะฐัััั ะฝะฐ ัััะฐะฝะธัะฐั
ะดะพะบะปะฐะดะฐ
rus_verbs:ัะบะพะฝัะตะฝััะธัะพะฒะฐัั{}, // ัะบะพะฝัะตะฝััะธัะพะฒะฐัั ะฝะฐ ะปะตะฒะพะผ ัะปะฐะฝะณะต
rus_verbs:ัะฐััะตัะฐัั{}, // ัะฐััะตัะฐัั ะฝะฐ ะผะฐะบััะบะต
rus_verbs:ะฟะปะฐะฒะธัััั{}, // ะฟะปะฐะฒะธัััั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ัะตะดะฐะบัะธัะพะฒะฐัั{}, // ัะตะดะฐะบัะธัะพะฒะฐัั ะฝะฐ ะฝะพััะฑัะบะต
rus_verbs:ะฟะพะดัะบะฐะบะธะฒะฐัั{}, // ะฟะพะดัะบะฐะบะธะฒะฐัั ะฝะฐ ะผะตััะต
rus_verbs:ะฟะพะบัะฟะฐัััั{}, // ะฟะพะบัะฟะฐัััั ะฝะฐ ััะฝะบะต
rus_verbs:ะฟัะพะผััะปััั{}, // ะฟัะพะผััะปััั ะฝะฐ ะผะตะปะบะพะฒะพะดัะต
rus_verbs:ะฟัะธะพะฑัะตัะฐัััั{}, // ะฟัะธะพะฑัะตัะฐัััั ะฝะฐ ัะฐัะฟัะพะดะฐะถะฐั
rus_verbs:ะฝะฐะธะณััะฒะฐัั{}, // ะฝะฐะธะณััะฒะฐัั ะฝะฐ ะฑะฐะฝะดะถะพ
rus_verbs:ะผะฐะฝะตะฒัะธัะพะฒะฐัั{}, // ะผะฐะฝะตะฒัะธัะพะฒะฐัั ะฝะฐ ัะปะฐะฝะณะฐั
rus_verbs:ะทะฐะฟะตัะฐัะปะตัััั{}, // ะทะฐะฟะตัะฐัะปะตัััั ะฝะฐ ะทะฐะฟะธััั
ะบะฐะผะตั
rus_verbs:ัะบััะฒะฐัั{}, // ัะบััะฒะฐัั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะฟะพะดะพัะฒะฐัััั{}, // ะฟะพะดะพัะฒะฐัััั ะฝะฐ ััะณะฐัะต
rus_verbs:ะทะฐะบัะตะฟะธัััั{}, // ะทะฐะบัะตะฟะธัััั ะฝะฐ ะทะฐะฝัััั
ะฟะพะทะธัะธัั
rus_verbs:ะณัะพะผัั
ะฐัั{}, // ะณัะพะผัั
ะฐัั ะฝะฐ ะบัั
ะฝะต
ะธะฝัะธะฝะธัะธะฒ:ะฟะพะดะฒะธะณะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฟะพะดะฒะธะณะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, // ะฟะพะดะฒะธะณะฐัััั ะฝะฐ ะฟะพะปั
ะดะตะตะฟัะธัะฐััะธะต:ะฟะพะดะฒะธะณะฐะฒัะธัั{},
rus_verbs:ะดะพะฑัะฒะฐัััั{}, // ะดะพะฑัะฒะฐัััั ะฝะฐ ัะตััะธัะพัะธะธ ะะฝะณะพะปั
rus_verbs:ะฟัะธะฟะปัััะฒะฐัั{}, // ะฟัะธะฟะปัััะฒะฐัั ะฝะฐ ััะตะฝะต
rus_verbs:ะดะพะถะธะฒะฐัั{}, // ะดะพะถะธะฒะฐัั ะฝะฐ ะฑะพะปัะฝะธัะฝะพะน ะบะพะนะบะต
rus_verbs:ะพัะฟัะฐะทะดะฝะพะฒะฐัั{}, // ะพัะฟัะฐะทะดะฝะพะฒะฐัั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ัะณัะฑะธัั{}, // ัะณัะฑะธัั ะฝะฐ ะบะพัะฝั
rus_verbs:ัั
ะพัะพะฝะธัั{}, // ัั
ะพัะพะฝะธัั ะฝะฐ ะบะปะฐะดะฑะธัะต
rus_verbs:ัััะบะฝะตัั{}, // ัััะบะฝะตัั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ัะบะพะฟะธัั{}, // ัะบะพะฟะธัั ะฝะฐ ััะตัั
rus_verbs:ะฟะพะผััั{}, // ะฟะพะผััั ะฝะฐ ัะฒะพะตะผ ััะฐะถะต
rus_verbs:ะฟะพัะพัั{}, // ะฟะพัะพัั ะฝะฐ ะบะพะฝััะฝะต
rus_verbs:ะฝะฐะปะธัะตััะฒะพะฒะฐัั{}, // ะฝะฐะปะธัะตััะฒะพะฒะฐัั ะฝะฐ ัะบะปะฐะดะต
rus_verbs:ะฝะฐััะฟัะฒะฐัั{}, // ะฝะฐััะฟัะฒะฐัั ะฝะฐ ะฟะพะปะบะต
rus_verbs:ะทะผะตะธัััั{}, // ะทะผะตะธัััั ะฝะฐ ะดะฝะต
rus_verbs:ะฟะพะถะตะปัะตัั{}, // ะฟะพะถะตะปัะตัั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะทะฐะพัััะธัััั{}, // ะทะฐะพัััะธัััั ะฝะฐ ะบะพะฝัะต
rus_verbs:ัะฒะตะทัะธ{}, // ัะฒะตะทัะธ ะฝะฐ ะฟะพะปะต
rus_verbs:ะฟัะพััะฒััะฒะพะฒะฐัั{}, // ะฟัะพััะฒััะฒะพะฒะฐัั ะฝะฐ ัะฒะพะตะน ัะบััะต
rus_verbs:ะฟะพะดะบัััะธัั{}, // ะฟะพะดะบัััะธัั ะฝะฐ ะฟัะธะฑะพัะฝะพะน ะฟะฐะฝะตะปะธ
rus_verbs:ััะฑะธัััั{}, // ััะฑะธัััั ะฝะฐ ะผะตัะฐั
rus_verbs:ัะธะถะธะฒะฐัั{}, // ัะธะถะธะฒะฐัั ะฝะฐ ะบััะปััะต
rus_verbs:ัะฐัะฐัะพัะธัั{}, // ัะฐัะฐัะพัะธัั ะฝะฐ ะธะฝะพัััะฐะฝะฝะพะผ ัะทัะบะต
rus_verbs:ัะตะฟะปะตัั{}, // ัะตะฟะปะตัั ะฝะฐ ัะตัะดัะต
rus_verbs:ะฟะพะบะฐัะฐัััั{}, // ะฟะพะบะฐัะฐัััั ะฝะฐ ะฒะตัะบะต
rus_verbs:ัะพััะตะดะพัะพัะธะฒะฐัััั{}, // ัะพััะตะดะพัะพัะธะฒะฐัััั ะฝะฐ ะณะปะฐะฒะฝะพะน ะทะฐะดะฐัะต
rus_verbs:ัะฐะทะฒัะทัะฒะฐัั{}, // ัะฐะทะฒัะทัะฒะฐัั ะฝะฐ ะฑะพัะธะฝะบะฐั
rus_verbs:ะฟะพะดะฒะพะทะธัั{}, // ะฟะพะดะฒะพะทะธัั ะฝะฐ ะผะพัะพัะพะปะปะตัะต
rus_verbs:ะฒััะธะฒะฐัั{}, // ะฒััะธะฒะฐัั ะฝะฐ ััะฑะฐัะบะต
rus_verbs:ัะบัะฟะฐัั{}, // ัะบัะฟะฐัั ะฝะฐ ะพัะบัััะพะผ ััะฝะบะต
rus_verbs:ะพัะพัะผะปััั{}, // ะพัะพัะผะปััั ะฝะฐ ะฒัััะตัะต
rus_verbs:ัะฐัะฟััะบะฐัััั{}, // ัะฐัะฟััะบะฐัััั ะฝะฐ ะบะปัะผะฑะฐั
rus_verbs:ะฟัะพะณะพัะตัั{}, // ะฟัะพะณะพัะตัั ะฝะฐ ัะฟะตะบัะปััะธัั
rus_verbs:ะฟัะธะฟะพะปะทัะธ{}, // ะฟัะธะฟะพะปะทัะธ ะฝะฐ ะบะพะปะตะฝัั
rus_verbs:ะทะฐะณะพัะตัั{}, // ะทะฐะณะพัะตัั ะฝะฐ ะฟะปัะถะต
rus_verbs:ะพัััะดะธัั{}, // ะพัััะดะธัั ะฝะฐ ะฑะฐะปะบะพะฝะต
rus_verbs:ะฝะฐัะฒะฐัั{}, // ะฝะฐัะฒะฐัั ะฝะฐ ะฟะพะปัะฝะต
rus_verbs:ะธะทะดะพั
ะฝััั{}, // ะธะทะดะพั
ะฝััั ะฝะฐ ะฑะพะปะพัะต
rus_verbs:ัะฐะทะณััะถะฐัั{}, // ัะฐะทะณััะถะฐัั ะฝะฐ ะดะพัะพะณะต
rus_verbs:ะฟัะพะธะทัะฐััะฐัั{}, // ะฟัะพะธะทัะฐััะฐัั ะฝะฐ ะฑะพะปะพัะฐั
rus_verbs:ัะฐะทััััั{}, // ัะฐะทััััั ะฝะฐ ะบะพะฒัะธะบะต
rus_verbs:ัะพะพััะถะฐัั{}, // ัะพะพััะถะฐัั ะฝะฐ ะฟะปะพัะฐะดะธ
rus_verbs:ะทะฐัะธััะฒะฐัั{}, // ะทะฐัะธััะฒะฐัั ะฝะฐ ะผะธัะธะฝะณะต
rus_verbs:ัะผะตััะธัััั{}, // ัะผะตััะธัััั ะฝะฐ ะปะฐะดะพะฝะธ
rus_verbs:ะทะฐะบัะฟะธัั{}, // ะทะฐะบัะฟะธัั ะฝะฐ ััะฝะบะต
rus_verbs:ะณะพัะปะฐะฝะธัั{}, // ะณะพัะปะฐะฝะธัั ะฝะฐ ัะปะธัะต
rus_verbs:ัะบะพะฝะพะผะธัั{}, // ัะบะพะฝะพะผะธัั ะฝะฐ ัะฟะธัะบะฐั
rus_verbs:ะธัะฟัะฐะฒะปััั{}, // ะธัะฟัะฐะฒะปััั ะฝะฐ ะดะพัะบะต
rus_verbs:ัะฐััะปะฐะฑะปััััั{}, // ัะฐััะปะฐะฑะปััััั ะฝะฐ ะปะตะถะฐะบะต
rus_verbs:ัะบะฐะฟะปะธะฒะฐัััั{}, // ัะบะฐะฟะปะธะฒะฐัััั ะฝะฐ ะบัััะต
rus_verbs:ัะฟะปะตัะฝะธัะฐัั{}, // ัะฟะปะตัะฝะธัะฐัั ะฝะฐ ัะบะฐะผะตะตัะบะต
rus_verbs:ะพััะตะทะถะฐัั{}, // ะพััะตะทะถะฐัั ะฝะฐ ะปะธะผัะทะธะฝะต
rus_verbs:ะพััะธััะฒะฐัั{}, // ะพััะธััะฒะฐัั ะฝะฐ ัะพะฑัะฐะฝะธะธ
rus_verbs:ััะพะบััะธัะพะฒะฐัั{}, // ััะพะบััะธัะพะฒะฐัั ะฝะฐ ัะดะฐะปะตะฝะฝะพะน ัะพัะบะต
rus_verbs:ะฟะพััะตะฒะฐัั{}, // ะฟะพััะตะฒะฐัั ะฝะฐ ะปะฐะฒัะฐั
rus_verbs:ะพะบะพะฟะฐัััั{}, // ะพะบะพะฟะฐัััั ะฝะฐ ะพะบัะฐะธะฝะต
rus_verbs:ะทะฐะณะพัะฐัั{}, // ะทะฐะณะพัะฐัั ะฝะฐ ะฟะปัะถะต
rus_verbs:ะพะฑะณะพัะตัั{}, // ะพะฑะณะพัะตัั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ัะฐัะฟะพะทะฝะฐะฒะฐัั{}, // ัะฐัะฟะพะทะฝะฐะฒะฐัั ะฝะฐ ัะพัะพะณัะฐัะธะธ
rus_verbs:ะทะฐะฟะปะตัะฐัััั{}, // ะทะฐะฟะปะตัะฐัััั ะฝะฐ ะผะฐะบััะบะต
rus_verbs:ะฟะตัะตะณัะตัััั{}, // ะฟะตัะตะณัะตัััั ะฝะฐ ะถะฐัะต
rus_verbs:ะฟะพะดะผะตัะฐัั{}, // ะฟะพะดะผะตัะฐัั ะฝะฐ ะบััะปััะต
rus_verbs:ะฝะฐัะธัะพะฒะฐัััั{}, // ะฝะฐัะธัะพะฒะฐัััั ะฝะฐ ะณะพัะธะทะพะฝัะต
rus_verbs:ะฟัะพัะบะฐะบะธะฒะฐัั{}, // ะฟัะพัะบะฐะบะธะฒะฐัั ะฝะฐ ัะบัะฐะฝะต
rus_verbs:ะฟะพะฟะธะฒะฐัั{}, // ะฟะพะฟะธะฒะฐัั ะฝะฐ ะฑะฐะปะบะพะฝะต ัะฐะน
rus_verbs:ะพัะฟะปัะฒะฐัั{}, // ะพัะฟะปัะฒะฐัั ะฝะฐ ะปะพะดะบะต
rus_verbs:ัะธัะธะบะฐัั{}, // ัะธัะธะบะฐัั ะฝะฐ ะฒะตัะบะฐั
rus_verbs:ัะบัะฟะธัั{}, // ัะบัะฟะธัั ะฝะฐ ะพะฟัะพะฒัั
ะฑะฐะทะฐั
rus_verbs:ะฝะฐะบะพะปะพัั{}, // ะฝะฐะบะพะปะพัั ะฝะฐ ะบะพะถะต ะบะฐััะธะฝะบั
rus_verbs:ัะพะทัะตะฒะฐัั{}, // ัะพะทัะตะฒะฐัั ะฝะฐ ะฒะตัะบะต
rus_verbs:ะฟัะพะบะพะปะพัััั{}, // ะฟัะพะบะพะปะพัััั ะฝะฐ ะผะตะปะพัะธ
rus_verbs:ะบัััะฝััััั{}, // ะบัััะฝััััั ะฝะฐ ะทะฐะดะฝะตะผ ะบะพะปะตัะต
rus_verbs:ะฟะตัะตะฝะพัะตะฒะฐัั{}, // ะฟะตัะตะฝะพัะตะฒะฐัั ะฝะฐ ะฟะพััะพัะปะพะผ ะดะฒะพัะต
rus_verbs:ะบะพะฝัะตะฝััะธัะพะฒะฐัััั{}, // ะบะพะฝัะตะฝััะธัะพะฒะฐัััั ะฝะฐ ัะธะปัััะต
rus_verbs:ะพะดะธัะฐัั{}, // ะพะดะธัะฐัั ะฝะฐ ั
ััะพัะต
rus_verbs:ัะฟะฐัะฐัััั{}, // ัะฟะฐัะฐัััั ะฝะฐ ะปะพะดะบะต
rus_verbs:ะดะพะบะฐะทัะฒะฐัััั{}, // ะดะพะบะฐะทัะฒะฐัััั ะฝะฐ ัััะฐะฝะธัะฐั
ะบะฝะธะณะธ
rus_verbs:ะฟะพะทะฝะฐะฒะฐัััั{}, // ะฟะพะทะฝะฐะฒะฐัััั ะฝะฐ ัะธะฝะณะต
rus_verbs:ะทะฐะผัะบะฐัััั{}, // ะทะฐะผัะบะฐัััั ะฝะฐ ะผะตัะฐะปะปะธัะตัะบะพะผ ะฟัะตะดะผะตัะต
rus_verbs:ะทะฐะฟัะธะผะตัะธัั{}, // ะทะฐะฟัะธะผะตัะธัั ะฝะฐ ะฟัะธะณะพัะบะต
rus_verbs:ะฟัะพะดะตัะถะฐัั{}, // ะฟัะพะดะตัะถะฐัั ะฝะฐ ะผะพัะพะทะต
rus_verbs:ัะพััะธัะพะฒะฐัั{}, // ัะพััะธัะพะฒะฐัั ะฝะฐ ะฟะปะพัะฐั
rus_verbs:ัะพั
ะฝััั{}, // ัะพั
ะฝััั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะฒััะฒะธัั{}, // ะฒััะฒะธัั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััะธ
rus_verbs:ะทะฐัะตะดะฐัั{}, // ะทะฐัะตะดะฐัั ะฝะฐ ะบะฐัะตะดัะต
rus_verbs:ัะฐัะฟะปะฐัะธะฒะฐัััั{}, // ัะฐัะฟะปะฐัะธะฒะฐัััั ะฝะฐ ะฒัั
ะพะดะต
rus_verbs:ัะฒะตัะปะตัั{}, // ัะฒะตัะปะตัั ะฝะฐ ะณะพัะธะทะพะฝัะต
rus_verbs:ะทะฐะปะตะฟะตัะฐัั{}, // ะทะฐะปะตะฟะตัะฐัั ะฝะฐ ะฝะตะทะฝะฐะบะพะผะพะผ ัะทัะบะต
rus_verbs:ะฟะพะดััะธััะฒะฐัั{}, // ะฟะพะดััะธััะฒะฐัั ะฝะฐ ะฟะฐะปััะฐั
rus_verbs:ะทะฐัััั{}, // ะทะฐัััั ะฝะฐ ะฟัััััะต
rus_verbs:ััะพัะผะธัะพะฒะฐัััั{}, // ััะพัะผะธัะพะฒะฐัััั ะฝะฐ ะผะตััะต
rus_verbs:ัะฐะทะฒะตัััะฒะฐัััั{}, // ัะฐะทะฒะตัััะฒะฐัััั ะฝะฐ ะฟะปะพัะฐะดะบะต
rus_verbs:ะฝะฐะฑะธะฒะฐัั{}, // ะฝะฐะฑะธะฒะฐัั ะฝะฐ ะผะฐะฝะตะบะตะฝะฐั
rus_verbs:ะทะฐะผะตัะทะฐัั{}, // ะทะฐะผะตัะทะฐัั ะฝะฐ ะฒะตััั
rus_verbs:ัั
ะฒะฐััะฒะฐัั{}, // ัั
ะฒะฐััะฒะฐัั ะฝะฐ ะปะตัั
rus_verbs:ะฟะตัะตะฒะตััะธัั{}, // ะฟะตัะตะฒะตััะธัั ะฝะฐ ะ ััะธ
rus_verbs:ัะผะตัะธะฒะฐัั{}, // ัะผะตัะธะฒะฐัั ะฝะฐ ะฑะปัะดัะต
rus_verbs:ะฟัะพะถะดะฐัั{}, // ะฟัะพะถะดะฐัั ะฝะฐ ะฒั
ะพะดะต
rus_verbs:ะผะตัะทะฝััั{}, // ะผะตัะทะฝััั ะฝะฐ ะฒะตััั
rus_verbs:ัะฐััะธัะฐัั{}, // ัะฐััะธัะฐัั ะฝะฐ ะบะพะถะต
rus_verbs:ะฟะตัะตัะฟะฐัั{}, // ะฟะตัะตัะฟะฐะป ะฝะฐ ัะตะฝะพะฒะฐะปะต
rus_verbs:ัะฐััะตะบะฐัั{}, // ัะฐััะตะบะฐัั ะฝะฐ ัะบััะตัะต
rus_verbs:ะพะฟัะพะฒะตัะณะฝััั{}, // ะพะฟัะพะฒะตัะณะฝััั ะฝะฐ ะฒัััะตะผ ััะพะฒะฝะต
rus_verbs:ะดััั
ะฝััั{}, // ะดััั
ะฝััั ะฝะฐ ะดะธะฒะฐะฝะต
rus_verbs:ัะฐัะฟััั{}, // ัะฐัะฟััั ะฝะฐ ะบัะตััะต
rus_verbs:ะทะฐะฟะตัััั{}, // ะทะฐะฟะตัััั ะฝะฐ ะบะพัััะต
rus_verbs:ะทะฐััะธะปะฐัั{}, // ะทะฐััะธะปะฐัั ะฝะฐ ะฑะฐะปะบะพะฝะต
rus_verbs:ัััะบะฐัััั{}, // ัััะบะฐัััั ะฝะฐ ะพะณะพัะพะดะต
rus_verbs:ัะฐะทะพัะธัััั{}, // ัะฐะทะพัะธัััั ะฝะฐ ะฟัะพะดะฐะถะต ัะฟะธัะตะบ
rus_verbs:ะฟะตัะตะดะตะปะฐัั{}, // ะฟะตัะตะดะตะปะฐัั ะฝะฐ ััะฐะฝะบะต
rus_verbs:ัะฐะทัััะฝััั{}, // ัะฐะทัััะฝััั ะฝะฐ ัััะฐะฝะธัะฐั
ะณะฐะทะตัั
rus_verbs:ะฟะพัะตะดะตัั{}, // ะฟะพัะตะดะตัั ะฝะฐ ะฒะธัะบะฐั
rus_verbs:ะฟัะพัะฐัะธัั{}, // ะฟัะพัะฐัะธัั ะฝะฐ ัะฟะธะฝะต
rus_verbs:ะพัััะตััะฒะธัััั{}, // ะพัััะตััะฒะธัััั ะฝะฐ ะดะตะปะต
rus_verbs:ัะตะปะธัััั{}, // ัะตะปะธัััั ะฝะฐ ะพะบัะฐะธะฝะต
rus_verbs:ะพะฟะปะฐัะธะฒะฐัั{}, // ะพะฟะปะฐัะธะฒะฐัั ะฝะฐ ะฟะตัะฒะพะน ะบะฐััะต
rus_verbs:ะฟะตัะตะฒะพัะฐัะธะฒะฐัั{}, // ะฟะตัะตะฒะพัะฐัะธะฒะฐัั ะฝะฐ ัะบะพะฒะพัะพะดะบะต
rus_verbs:ัะฟัะฐะถะฝััััั{}, // ัะฟัะฐะถะฝััััั ะฝะฐ ะฑะฐัััะต
rus_verbs:ะธัะฟัะพะฑะพะฒะฐัั{}, // ะธัะฟัะพะฑะพะฒะฐัั ะฝะฐ ัะตะฑะต
rus_verbs:ัะฐะทะณะปะฐะดะธัััั{}, // ัะฐะทะณะปะฐะดะธัััั ะฝะฐ ัะฟะธะฝะต
rus_verbs:ัะธัะพะฒะฐัััั{}, // ัะธัะพะฒะฐัััั ะฝะฐ ััะตะบะปะต
rus_verbs:ะฟัะพะดัะพะณะฝััั{}, // ะฟัะพะดัะพะณะฝััั ะฝะฐ ะผะพัะพะทะต
rus_verbs:ะฟะพะผะตัะธัั{}, // ะฟะพะผะตัะธัั ะฝะฐ ะดะพัะบะต
rus_verbs:ะฟัะธััะธัั{}, // ะฟัะธััะธัั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะธะทะฑะธัะฐัั{}, // ะธะทะฑะธัะฐัั ะฝะฐ ะฟะตัะฒัั
ัะฒะพะฑะพะดะฝัั
ะฒัะฑะพัะฐั
rus_verbs:ะทะฐัะตะฒะฐัััั{}, // ะทะฐัะตะฒะฐัััั ะฝะฐ ะผะฐััะต
rus_verbs:ัะฟะปัะฒะฐัั{}, // ัะฟะปัะฒะฐัั ะฝะฐ ะบะฐัะตัะต
rus_verbs:ะทะฐะผะตััะฐัั{}, // ะทะฐะผะตััะฐัั ะฝะฐ ัะตะบะปะฐะผะฝะพะผ ัะธัะต
rus_verbs:ัะธะบัะธัะพะฒะฐัััั{}, // ัะธะบัะธัะพะฒะฐัััั ะฝะฐ ะดะพััะธะณะฝััะพะผ ััะพะฒะฝะต
rus_verbs:ะทะฐะฟะธัะฐัััั{}, // ะทะฐะฟะธัะฐัััั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะทะฐะณัะฑะธัั{}, // ะทะฐะณัะฑะธัั ะฝะฐ ะบะพัะฝั
rus_verbs:ัะฐะทะฒะตััััั{}, // ัะฐะทะฒะตััััั ะฝะฐ ะฟัะธัะพะดะต
rus_verbs:ััะตะทะถะฐัััั{}, // ััะตะทะถะฐัััั ะฝะฐ ะปะธะผัะทะธะฝะฐั
rus_verbs:ะฟะพัะฐะฝัะตะฒะฐัั{}, // ะฟะพัะฐะฝัะตะฒะฐัั ะฝะฐ ะผะพะณะธะปะต
rus_verbs:ะดะพั
ะฝััั{}, // ะดะพั
ะฝััั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะฟัะธะฟะฐัะบะพะฒะฐัััั{}, // ะฟัะธะฟะฐัะบะพะฒะฐัััั ะฝะฐ ะณะฐะทะพะฝะต
rus_verbs:ะพัั
ะฒะฐัะธัั{}, // ะพัั
ะฒะฐัะธัั ะฝะฐ ัะฐัะฟัะพะดะฐะถะต
rus_verbs:ะพัััะฒะฐัั{}, // ะพัััะฒะฐัั ะฝะฐ ัะปะธัะต
rus_verbs:ะฟะตัะตะฒะฐัะธะฒะฐัั{}, // ะฟะตัะตะฒะฐัะธะฒะฐัั ะฝะฐ ะฒััะพะบะพะน ะฒะตัะบะต
rus_verbs:ะฟะพะดะฒะตัะธัั{}, // ะฟะพะดะฒะตัะธัั ะฝะฐ ะฒะตัะตะฒะบะต
rus_verbs:ั
ะฒะฐััะฐัั{}, // ั
ะฒะฐััะฐัั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ะพััะฐะฑะฐััะฒะฐัั{}, // ะพััะฐะฑะฐััะฒะฐัั ะฝะฐ ัะฑะพัะบะต ััะพะถะฐั
rus_verbs:ัะฐะทะปะตัััั{}, // ัะฐะทะปะตัััั ะฝะฐ ะฟะพะปั
rus_verbs:ะพัะตััะธัั{}, // ะพัะตััะธัั ะฝะฐ ะฟะพะปั
rus_verbs:ะฟัะตะดัะตะดะฐัะตะปัััะฒะพะฒะฐัั{}, // ะฟัะตะดัะตะดะฐัะตะปัััะฒะพะฒะฐัั ะฝะฐ ัะพะฑัะฐะฝะธะธ
rus_verbs:ัะบะพะฝััะทะธัััั{}, // ัะบะพะฝััะทะธัััั ะฝะฐ ััะตะฝะต
rus_verbs:ะฒััะฒะปััััั{}, // ะฒััะฒะปััััั ะฝะฐ ัะธะฝะณะต
rus_verbs:ะบัััะฐะฝััััั{}, // ะบัััะฐะฝััััั ะฝะฐ ะทะฐะดะฝะตะผ ะบะพะปะตัะต
rus_verbs:ะบะฐัะฐัะปะธัั{}, // ะบะฐัะฐัะปะธัั ะฝะฐ ะฒั
ะพะดะต
rus_verbs:ะฟะตัะตัะธัะปััั{}, // ะฟะตัะตัะธัะปััั ะฝะฐ ะฟะฐะปััะฐั
rus_verbs:ะพะฑัะฐะฑะฐััะฒะฐัั{}, // ะพะฑัะฐะฑะฐััะฒะฐัั ะฝะฐ ััะฐะฝะบะต
rus_verbs:ะฝะฐััะธะณะฐัั{}, // ะฝะฐััะธะณะฐัั ะฝะฐ ะฑะตัะตะณั
rus_verbs:ัะฐะทะณัะปะธะฒะฐัั{}, // ัะฐะทะณัะปะธะฒะฐัั ะฝะฐ ะฑะตัะตะณั
rus_verbs:ะฝะฐัะธะปะพะฒะฐัั{}, // ะฝะฐัะธะปะพะฒะฐัั ะฝะฐ ะฟะปัะถะต
rus_verbs:ะฟะพัะตะดะตัั{}, // ะฟะพัะตะดะตัั ะฝะฐ ะผะฐะบััะบะต
rus_verbs:ััะธััะฒะฐัั{}, // ััะธััะฒะฐัั ะฝะฐ ะฑะฐะปะฐะฝัะต
rus_verbs:ะทะฐัะพะถะดะฐัััั{}, // ะทะฐัะพะถะดะฐัััั ะฝะฐ ะฑะพะปััะพะน ะณะปัะฑะธะฝะต
rus_verbs:ัะฐัะฟัะพัััะฐะฝััั{}, // ัะฐัะฟัะพัััะฐะฝััั ะฝะฐ ัะฐะนัะฐั
rus_verbs:ะฟะธัะพะฒะฐัั{}, // ะฟะธัะพะฒะฐัั ะฝะฐ ะฒะตััะธะฝะต ั
ะพะปะผะฐ
rus_verbs:ะฝะฐัะตััะฐัั{}, // ะฝะฐัะตััะฐัั ะฝะฐ ััะตะฝะต
rus_verbs:ัะฐััะฒะตัะฐัั{}, // ัะฐััะฒะตัะฐัั ะฝะฐ ะฟะพะดะพะบะพะฝะฝะธะบะต
rus_verbs:ัะผะฝะตัั{}, // ัะผะฝะตัั ะฝะฐ ะณะปะฐะทะฐั
rus_verbs:ัะฐัััะฒะพะฒะฐัั{}, // ัะฐัััะฒะพะฒะฐัั ะฝะฐ ะพะบัะฐะธะฝะต
rus_verbs:ะทะฐะบัััะธัััั{}, // ะทะฐะบัััะธัััั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ะพััะฐะฑะพัะฐัั{}, // ะพััะฐะฑะพัะฐัั ะฝะฐ ัะฐั
ัะต
rus_verbs:ะฟะพะปะตัั{}, // ะฟะพะปะตัั ะฝะฐ ะฟะพะปะต ะฑัะฐะฝะธ
rus_verbs:ัะตะฑะตัะฐัั{}, // ัะตะฑะตัะฐัั ะฝะฐ ะฒะตัะบะต
rus_verbs:ะฟะพะดัะตัะบะธะฒะฐัััั{}, // ะฟะพะดัะตัะบะธะฒะฐัััั ะฝะฐ ัะฐะนัะต
rus_verbs:ะฟะพัะตััั{}, // ะฟะพัะตััั ะฝะฐ ะดััะณะพะผ ะฟะพะปะต
rus_verbs:ะทะฐะผะตัะฐัััั{}, // ะทะฐะผะตัะฐัััั ะฝะฐ ะฟะฐััะฑะธัะต
rus_verbs:ะฟัะพััะธัะฐัั{}, // ะฟัะพััะธัะฐัั ะฝะฐ ะฟะฐะปััะฐั
rus_verbs:ะณะพะปะพัะพะฒะฐัั{}, // ะณะพะปะพัะพะฒะฐัั ะฝะฐ ััะฐััะต
rus_verbs:ะผะฐััััั{}, // ะผะฐััััั ะฝะฐ ะฟะปัะถะต
rus_verbs:ัะบะพะปะพัะธัั{}, // ัะบะพะปะพัะธัั ะฝะฐ ัะปัะถะฑะต
rus_verbs:ะพะฑัะตัะฐัััั{}, // ะพะฑัะตัะฐัััั ะฝะฐ ััะถะฑะธะฝะต
rus_verbs:ะพะฑะปะธะฒะฐัััั{}, // ะพะฑะปะธะฒะฐัััั ะฝะฐ ัะปะธัะต
rus_verbs:ะบะฐัะฐัั{}, // ะบะฐัะฐัั ะฝะฐ ะปะพัะฐะดะบะต
rus_verbs:ะฟัะธะฟัััะฐัั{}, // ะฟัะธะฟัััะฐัั ะฝะฐ ัะตะปะต
rus_verbs:ะทะฐะฟะฐะฝะธะบะพะฒะฐัั{}, // ะทะฐะฟะฐะฝะธะบะพะฒะฐัั ะฝะฐ ัะบะทะฐะผะตะฝะต
ะธะฝัะธะฝะธัะธะฒ:ัะปะตัะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะปะตัะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะปะตัะฐัั ะฝะฐ ัะฐััะฝะพะผ ัะฐะผะพะปะตัะต
ะดะตะตะฟัะธัะฐััะธะต:ัะปะตัะฐะฒ{},
rus_verbs:ัััะฑะธัั{}, // ัััะฑะธัั ะดะตะฝะตะณ ะฝะฐ ัะฟะตะบัะปััะธัั
rus_verbs:ะทะฐะถะธะณะฐัััั{}, // ะทะฐะถะธะณะฐัััั ะฝะฐ ัะปะธัะต
rus_verbs:ะถะฐัะธัั{}, // ะถะฐัะธัั ะฝะฐ ัะณะปัั
rus_verbs:ะฝะฐะบะฐะฟะปะธะฒะฐัััั{}, // ะฝะฐะบะฐะฟะปะธะฒะฐัััั ะฝะฐ ััะตัั
rus_verbs:ัะฐัะฟัััะธัััั{}, // ัะฐัะฟัััะธัััั ะฝะฐ ะณััะดะบะต
rus_verbs:ัะฐััะฐะถะธะฒะฐัััั{}, // ัะฐััะฐะถะธะฒะฐัััั ะฝะฐ ะผะตััะฐั
rus_verbs:ัััะฐะฝััะฒะพะฒะฐัั{}, // ัััะฐะฝััะฒะพะฒะฐัั ะฝะฐ ะปะพัะฐะดะธ
rus_verbs:ะพัะผะฐััะธะฒะฐัััั{}, // ะพัะผะฐััะธะฒะฐัััั ะฝะฐ ะผะตััะต
rus_verbs:ัะฐะทะฒะพัะฐัะธะฒะฐัั{}, // ัะฐะทะฒะพัะฐัะธะฒะฐัั ะฝะฐ ะทะฐะฒะพะตะฒะฐะฝะฝะพะน ัะตััะธัะพัะธะธ
rus_verbs:ัะพะณัะตะฒะฐัั{}, // ัะพะณัะตะฒะฐัั ะฝะฐ ะฒะตััะธะฝะต ะณะพัั
rus_verbs:ะทะฐัะบััะฐัั{}, // ะทะฐัะบััะฐัั ะฝะฐ ะฒะฐั
ัะต
rus_verbs:ะฟะตัะตะบััะธัั{}, // ะฟะตัะตะบััะธัั ะฝะฐ ะฑะตะณั
rus_verbs:ะฟัะธะฟะปััั{}, // ะฟัะธะฟะปััั ะฝะฐ ััะธะผะฐัะฐะฝะต
rus_verbs:ะทะฐะถะธะณะฐัั{}, // ะทะฐะถะธะณะฐัั ะฝะฐ ัะฐะฝัะฐั
rus_verbs:ะทะฐะบะพะฟะฐัั{}, // ะทะฐะบะพะฟะฐัั ะฝะฐ ะฟะพะปัะฝะต
rus_verbs:ััะธัะฐัั{}, // ััะธัะฐัั ะฝะฐ ะฑะตัะตะณั
rus_verbs:ะฟะพะดััะตัะตะณะฐัั{}, // ะฟะพะดััะตัะตะณะฐัั ะฝะฐ ะฟะพะดั
ะพะดะต
rus_verbs:ะฟะพะณัะปััั{}, // ะฟะพะณัะปััั ะฝะฐ ัะฒะฐะดัะฑะต
rus_verbs:ะพะณะปะฐัะธัั{}, // ะพะณะปะฐัะธัั ะฝะฐ ะผะธัะธะฝะณะต
rus_verbs:ัะฐะทะฑะพะณะฐัะตัั{}, // ัะฐะทะฑะพะณะฐัะตัั ะฝะฐ ะฟัะธะธัะบะต
rus_verbs:ะณัะพั
ะพัะฐัั{}, // ะณัะพั
ะพัะฐัั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ัะฐัะฟะพะปะพะถะธัั{}, // ัะฐัะฟะพะปะพะถะธัั ะฝะฐ ะณัะฐะฝะธัะต
rus_verbs:ัะตะฐะปะธะทะพะฒะฐัััั{}, // ัะตะฐะปะธะทะพะฒะฐัััั ะฝะฐ ะฝะพะฒะพะน ัะฐะฑะพัะต
rus_verbs:ะทะฐัััะฒะฐัั{}, // ะทะฐัััะฒะฐัั ะฝะฐ ะผะพัะพะทะต
rus_verbs:ะทะฐะฟะตัะฐัะปะตัั{}, // ะทะฐะฟะตัะฐัะปะตัั ะฝะฐ ะฟะปะตะฝะบะต
rus_verbs:ััะตะฝะธัะพะฒะฐัััั{}, // ััะตะฝะธัะพะฒะฐัััั ะฝะฐ ะผะฐะฝะตะบะตะฝะต
rus_verbs:ะฟะพัะฟะพัะธัั{}, // ะฟะพัะฟะพัะธัั ะฝะฐ ัะพะฒะตัะฐะฝะธะธ
rus_verbs:ะทะฐััะณะธะฒะฐัั{}, // ะทะฐััะณะธะฒะฐัั ะฝะฐ ะฟะพััะต
rus_verbs:ะทะธะถะดะธัััั{}, // ะทะธะถะดะธัััั ะฝะฐ ัะฒะตัะดะพะน ะพัะฝะพะฒะต
rus_verbs:ะฟะพัััะพะธัััั{}, // ะฟะพัััะพะธัััั ะฝะฐ ะฟะตัะบะต
rus_verbs:ะฝะฐะดััะฒะฐัััั{}, // ะฝะฐะดััะฒะฐัััั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ะทะฐะบะธะฟะฐัั{}, // ะทะฐะบะธะฟะฐัั ะฝะฐ ะฟะปะธัะต
rus_verbs:ะทะฐัะพะฝััั{}, // ะทะฐัะพะฝััั ะฝะฐ ะผะตะปะบะพะฒะพะดัะต
rus_verbs:ะฟะพะฑััั{}, // ะฟะพะฑััั ะฝะฐ ัะฐะทะตะฝะดะต
rus_verbs:ัะณะพัะฐัั{}, // ัะณะพัะฐัั ะฝะฐ ัะพะปะฝัะต
ะธะฝัะธะฝะธัะธะฒ:ะฟะพะฟะธัะฐัั{ aux stress="ะฟะพะฟ^ะธัะฐัั" }, ะณะปะฐะณะพะป:ะฟะพะฟะธัะฐัั{ aux stress="ะฟะพะฟ^ะธัะฐัั" }, // ะฟะพะฟะธัะฐัั ะฝะฐ ัะปะธัะต
ะดะตะตะฟัะธัะฐััะธะต:ะฟะพะฟะธัะฐะฒ{ aux stress="ะฟะพะฟ^ะธัะฐะฒ" },
rus_verbs:ะฟะพะดัะฐัััั{}, // ะฟะพะดัะฐัััั ะฝะฐ ััะตะฝะต
rus_verbs:ะทะฐะฟัะฐะฒะธัั{}, // ะทะฐะฟัะฐะฒะธัั ะฝะฐ ะฟะพัะปะตะดะฝะตะน ะทะฐะฟัะฐะฒะบะต
rus_verbs:ะพะฑะพะทะฝะฐัะฐัััั{}, // ะพะฑะพะทะฝะฐัะฐัััั ะฝะฐ ะบะฐััะต
rus_verbs:ะฟัะพัะธะถะธะฒะฐัั{}, // ะฟัะพัะธะถะธะฒะฐัั ะฝะฐ ะฑะตัะตะณั
rus_verbs:ะฝะฐัะตััะธัั{}, // ะฝะฐัะตััะธัั ะฝะฐ ะปะธััะบะต
rus_verbs:ัะพัะผะพะทะธัั{}, // ัะพัะผะพะทะธัั ะฝะฐ ะปัะดั
rus_verbs:ะทะฐัะตะฒะฐัั{}, // ะทะฐัะตะฒะฐัั ะฝะฐ ะบะพัะผะธัะตัะบะพะน ะฑะฐะทะต
rus_verbs:ะทะฐะดะตัะถะธะฒะฐัั{}, // ะทะฐะดะตัะถะธะฒะฐัั ะฝะฐ ัะฐะผะพะถะฝะต
rus_verbs:ะฟัะธะปะตัะฐัั{}, // ะฟัะธะปะตัะฐัั ะฝะฐ ัะฐััะฝะพะผ ัะฐะผะพะปะตัะต
rus_verbs:ะฟะพะปัะปะตะถะฐัั{}, // ะฟะพะปัะปะตะถะฐัั ะฝะฐ ััะฐะฒะบะต
rus_verbs:ะตัะทะฐัั{}, // ะตัะทะฐัั ะฝะฐ ัะฐะฑััะตัะบะต
rus_verbs:ะฟะพะบะพะฟะฐัััั{}, // ะฟะพะบะพะฟะฐัััั ะฝะฐ ัะบะปะฐะดะต
rus_verbs:ะฟะพะดะฒะตะทัะธ{}, // ะฟะพะดะฒะตะทัะธ ะฝะฐ ะผะฐัะธะฝะต
rus_verbs:ะฟะพะปะตะถะฐัั{}, // ะฟะพะปะตะถะฐัั ะฝะฐ ะฒะพะดะฝะพะผ ะผะฐััะฐัะต
rus_verbs:ััััั{}, // ััััั ะฝะฐ ัะปะธัะต
rus_verbs:ัััะฝััั{}, // ัััะฝััั ะฝะฐ ัะปะธัะต
rus_verbs:ัะบัะตััะธัััั{}, // ัะบัะตััะธัััั ะฝะฐ ะณััะดะธ
rus_verbs:ะฟัะธะฟะฐัะบะพะฒะฐัั{}, // ะฟัะธะฟะฐัะบะพะฒะฐัั ะฝะฐ ััะพัะฝะบะต
rus_verbs:ะทะดะพัะพะฒะฐัััั{}, // ะทะดะพัะพะฒะฐัััั ะฝะฐ ะบะฐัะตะดัะต
rus_verbs:ะฝะฐัะฐัะฐะฟะฐัั{}, // ะฝะฐัะฐัะฐะฟะฐัั ะฝะฐ ะฟะฐััะต
rus_verbs:ะพัะบะพะฟะฐัั{}, // ะพัะบะพะฟะฐัั ะฝะฐ ะฟะพะปัะฝะต
rus_verbs:ัะผะฐััะตัะธัั{}, // ัะผะฐััะตัะธัั ะฝะฐ ะบะพะปะตะฝะบะฐั
rus_verbs:ะดะพะฒะตะทัะธ{}, // ะดะพะฒะตะทัะธ ะฝะฐ ะผะฐัะธะฝะต
rus_verbs:ะธะทะฑะธะฒะฐัั{}, // ะธะทะฑะธะฒะฐัั ะฝะฐ ะบัััะต
rus_verbs:ัะฒะฐัะธัั{}, // ัะฒะฐัะธัั ะฝะฐ ะบะพัััะต
rus_verbs:ะธัััะตะฑะธัั{}, // ะธัััะตะฑะธัั ะฝะฐ ะบะพัะฝั
rus_verbs:ัะฐัะบะพะฟะฐัั{}, // ัะฐัะบะพะฟะฐัั ะฝะฐ ะฑะพะปะพัะต
rus_verbs:ะฟะพะฟะธัั{}, // ะฟะพะฟะธัั ะฝะฐ ะบัั
ะฝะต
rus_verbs:ะทะฐะฟัะฐะฒะปััั{}, // ะทะฐะฟัะฐะฒะปััั ะฝะฐ ะฑะฐะทะต
rus_verbs:ะบััะฐัั{}, // ะบััะฐัั ะฝะฐ ะบัั
ะฝะต
rus_verbs:ะทะฐะผะพะปะบะฐัั{}, // ะทะฐะผะพะปะบะฐัั ะฝะฐ ะฟะพะปะพะฒะธะฝะต ััะฐะทั
rus_verbs:ะธะทะผะตัััััั{}, // ะธะทะผะตัััััั ะฝะฐ ะฒะตัะฐั
rus_verbs:ัะฑัะฒะฐัััั{}, // ัะฑัะฒะฐัััั ะฝะฐ ัะฐะผะพะผ ะดะตะปะต
rus_verbs:ะธะทะพะฑัะฐะถะฐัััั{}, // ะธะทะพะฑัะฐะถะฐะตััั ะฝะฐ ััะตะฝะต
rus_verbs:ัะธะบัะธัะพะฒะฐัั{}, // ัะธะบัะธัะพะฒะฐัั ะฝะฐ ะดะฐะฝะฝะพะน ะฒััะพัะต
rus_verbs:ะพัะปะฐะฑะปััั{}, // ะพัะปะฐะฑะปััั ะฝะฐ ัะตะต
rus_verbs:ะทัะตัั{}, // ะทัะตัั ะฝะฐ ะณััะดะบะต
rus_verbs:ะทะตะปะตะฝะตัั{}, // ะทะตะปะตะฝะตัั ะฝะฐ ะณััะดะบะต
rus_verbs:ะบัะธัะธะบะพะฒะฐัั{}, // ะบัะธัะธะบะพะฒะฐัั ะฝะฐ ัััะฐะฝะธัะฐั
ะณะฐะทะตัั
rus_verbs:ะพะฑะปะตัะตัั{}, // ะพะฑะปะตัะตัั ะฝะฐ ัะฐะผะพะปะตัะต
rus_verbs:ะทะฐัะฐะทะธัััั{}, // ะทะฐัะฐะทะธัััั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ัะฐััะตััั{}, // ัะฐััะตััั ะฝะฐ ัะตััะธัะพัะธะธ
rus_verbs:ะฟะตัััั{}, // ะฟะตัััั ะฝะฐ ะบะพัััะต
rus_verbs:ะฟะพัะฟะฐัั{}, // ะฟะพัะฟะฐัั ะฝะฐ ะทะตะผะปะต
rus_verbs:ัะฟะปะตัะฐัััั{}, // ัะฟะปะตัะฐัััั ะฝะฐ ะผะฐะบััะบะต
rus_verbs:ัะดะตัะถะธะฒะฐัััั{}, // ัะดะตัะถะธะฒะฐัััั ะฝะฐ ัะฐัััะพัะฝะธะธ
rus_verbs:ะฟะพะผะตัะฐัััั{}, // ะฟะพะผะตัะฐัััั ะฝะฐ ัะธััะพัะต
rus_verbs:ะปะธะบะฒะธะดะธัะพะฒะฐัั{}, // ะปะธะบะฒะธะดะธัะพะฒะฐัั ะฝะฐ ะฟะพะปะธะณะพะฝะต
rus_verbs:ะฟัะพะฒะฐะปััััั{}, // ะฟัะพะฒะฐะปััััั ะฝะฐ ะดะธะฒะฐะฝะต
rus_verbs:ะปะตัะธัััั{}, // ะปะตัะธัััั ะฝะฐ ะดะพะผั
rus_verbs:ะพะฑัะฐะฑะพัะฐัั{}, // ะพะฑัะฐะฑะพัะฐัั ะฝะฐ ััะฐะฝะบะต
rus_verbs:ะทะฐัะตะปะบะฝััั{}, // ะทะฐัะตะปะบะฝััั ะฝะฐ ััะบะฐั
rus_verbs:ัะฐะทะฝะพัะธัั{}, // ัะฐะทะฝะพัะธัั ะฝะฐ ะพะดะตะถะดะต
rus_verbs:ัะตัะฐัั{}, // ัะตัะฐัั ะฝะฐ ะณััะดะธ
rus_verbs:ะฝะฐะปะฐะดะธัั{}, // ะฝะฐะปะฐะดะธัั ะฝะฐ ะบะพะฝะฒะตะนะตัะต ะฒัะฟััะบ
rus_verbs:ะพัััั
ะฝััััั{}, // ะพัััั
ะฝััััั ะฝะฐ ัะปะธัะต
rus_verbs:ัะฐะทัะณััะฒะฐัััั{}, // ัะฐะทัะณััะฒะฐัััั ะฝะฐ ัะบะฐัะบะฐั
rus_verbs:ะพะฑะตัะฟะตัะธะฒะฐัััั{}, // ะพะฑะตัะฟะตัะธะฒะฐัััั ะฝะฐ ะฒัะณะพะดะฝัั
ััะปะพะฒะธัั
rus_verbs:ะณัะตัััั{}, // ะณัะตัััั ะฝะฐ ะฒะพะบะทะฐะปะต
rus_verbs:ะทะฐัะธะดะตัััั{}, // ะทะฐัะธะดะตัััั ะฝะฐ ะพะดะฝะพะผ ะผะตััะต
rus_verbs:ะผะฐัะตัะธะฐะปะธะทะพะฒะฐัััั{}, // ะผะฐัะตัะธะฐะปะธะทะพะฒะฐัััั ะฝะฐ ะณัะฐะฝะธัะต
rus_verbs:ัะฐััะตะธะฒะฐัััั{}, // ัะฐััะตะธะฒะฐัััั ะฝะฐ ะฒััะพัะต ะฒะตััะธะฝ
rus_verbs:ะฟะตัะตะฒะพะทะธัั{}, // ะฟะตัะตะฒะพะทะธัั ะฝะฐ ะฟะปะฐััะพัะผะต
rus_verbs:ะฟะพะธะณัะฐัั{}, // ะฟะพะธะณัะฐัั ะฝะฐ ัะบัะธะฟะบะต
rus_verbs:ะฟะพัะพะฟัะฐัััั{}, // ะฟะพัะพะฟัะฐัััั ะฝะฐ ะพะดะฝะพะผ ะผะตััะต
rus_verbs:ะฟะตัะตะฟัะฐะฒะธัััั{}, // ะฟะตัะตะฟัะฐะฒะธัััั ะฝะฐ ะฟะปะพัั
rus_verbs:ะทะฐะฑัะตะทะถะธัั{}, // ะทะฐะฑัะตะทะถะธัั ะฝะฐ ะณะพัะธะทะพะฝัะต
rus_verbs:ะทะฐะฒัะฒะฐัั{}, // ะทะฐะฒัะฒะฐัั ะฝะฐ ะพะฟััะบะต
rus_verbs:ะทะฐะฒะฐัะธะฒะฐัั{}, // ะทะฐะฒะฐัะธะฒะฐัั ะฝะฐ ะบัั
ะพะฝัะบะต
rus_verbs:ะฟะตัะตะผะตัะฐัััั{}, // ะฟะตัะตะผะตัะฐัััั ะฝะฐ ัะฟะฐัะฐัะตะปัะฝะพะผ ะฟะปะพัั
ะธะฝัะธะฝะธัะธะฒ:ะฟะธัะฐัััั{ aux stress="ะฟะธั^ะฐัััั" }, ะณะปะฐะณะพะป:ะฟะธัะฐัััั{ aux stress="ะฟะธั^ะฐัััั" }, // ะฟะธัะฐัััั ะฝะฐ ะฑะปะฐะฝะบะต
rus_verbs:ะฟัะฐะทะดะฝะพะฒะฐัั{}, // ะฟัะฐะทะดะฝะพะฒะฐัั ะฝะฐ ัะปะธัะฐั
rus_verbs:ะพะฑััะธัั{}, // ะพะฑััะธัั ะฝะฐ ะบะพััะต
rus_verbs:ะพััะดะพะฒะฐัั{}, // ะพััะดะพะฒะฐัั ะฝะฐ ัะบะปะฐะดะต
rus_verbs:ะฟะพะดัะฐััะธ{}, // ะฟะพะดัะฐััะธ ะฝะฐ ะณะปัะดะบะต
rus_verbs:ัะตะปะตััะตัั{}, // ัะตะปะตััะตัั ะฝะฐ ะฒะตััั
rus_verbs:ัะฐะทะดะตะฒะฐัััั{}, // ัะฐะทะดะตะฒะฐัััั ะฝะฐ ะฟัะฑะปะธะบะต
rus_verbs:ะฟะพะพะฑะตะดะฐัั{}, // ะฟะพะพะฑะตะดะฐัั ะฝะฐ ะณะฐะทะพะฝะต
rus_verbs:ะถัะฐัั{}, // ะถัะฐัั ะฝะฐ ะฟะพะผะพะนะบะต
rus_verbs:ะธัะฟะพะปะฝััััั{}, // ะธัะฟะพะปะฝััััั ะฝะฐ ัะปะตะนัะต
rus_verbs:ะฟะพั
ะพะปะพะดะฐัั{}, // ะฟะพั
ะพะปะพะดะฐัั ะฝะฐ ัะปะธัะต
rus_verbs:ะณะฝะธัั{}, // ะณะฝะธัั ะฝะฐ ะบะฐัะพัะณะต
rus_verbs:ะฟัะพัะปััะฐัั{}, // ะฟัะพัะปััะฐัั ะฝะฐ ะบะพะฝัะตััะต
rus_verbs:ัะพะฒะตัะฐัััั{}, // ัะพะฒะตัะฐัััั ะฝะฐ ะทะฐัะตะดะฐะฝะธะธ
rus_verbs:ะฟะพะบะฐัะธะฒะฐัั{}, // ะฟะพะบะฐัะธะฒะฐัั ะฝะฐ ะฒะพะปะฝะฐั
rus_verbs:ะพััะธะดะตัั{}, // ะพััะธะดะตัั ะฝะฐ ะณะฐัะฟะฒะฐั
ัะต
rus_verbs:ัะพัะผะธัะพะฒะฐัั{}, // ัะพัะผะธัะพะฒะฐัั ะฝะฐ ัะตะบัะตัะฝะพะน ะฑะฐะทะต
rus_verbs:ะทะฐั
ัะฐะฟะตัั{}, // ะทะฐั
ัะฐะฟะตัั ะฝะฐ ะบัะพะฒะฐัะธ
rus_verbs:ะพะฑัะตั
ะฐัั{}, // ะพะฑัะตั
ะฐัั ะฝะฐ ะฟะพะฟััะบะต
rus_verbs:ะฟะพัะตะปะธัั{}, // ะฟะพัะตะปะธัั ะฝะฐ ะฒะตัั
ะฝะธั
ััะฐะถะฐั
rus_verbs:ะทะฐะฒะพัะพัะฐัััั{}, // ะทะฐะฒะพัะพัะฐัััั ะฝะฐ ัะตะฝะต
rus_verbs:ะฝะฐะฟัััะฐัั{}, // ะฝะฐะฟัััะฐัั ะฝะฐ ัะตะปะต
rus_verbs:ะพััั
ะฐัััั{}, // ะพััั
ะฐัััั ะฝะฐ ะทะตะผะปะต
rus_verbs:ะฟะพะปะธััะฐัั{}, // ะฟะพะปะธััะฐัั ะฝะฐ ะดะพััะณะต
rus_verbs:ะทะฐะฒะตััะตัั{}, // ะทะฐะฒะตััะตัั ะฝะฐ ัะตััะต
rus_verbs:ะฟะตัะฐัะฐัั{}, // ะฟะตัะฐัะฐัั ะฝะฐ ะฝะพััะต
rus_verbs:ะพัััะบะฐัััั{}, // ะพัััะบะฐัััั ะฝะฐ ัะบะปะฐะดะต
rus_verbs:ะทะฐัะธะบัะธัะพะฒะฐัั{}, // ะทะฐัะธะบัะธัะพะฒะฐัั ะฝะฐ ะฟะปะตะฝะบะต
rus_verbs:ัะฐัััะธะปะฐัััั{}, // ัะฐัััะธะปะฐัััั ะฝะฐ ััะพะปะต
rus_verbs:ะทะฐะผะตััะธัั{}, // ะทะฐะผะตััะธัั ะฝะฐ ะฟะพััั
rus_verbs:ัะณะฐัะฐัั{}, // ัะณะฐัะฐัั ะฝะฐ ะฝะตัะฟัะฐะฒะปัะตะผะพะผ ะบะพัะฐะฑะปะต
rus_verbs:ััะฐะทะธัั{}, // ััะฐะทะธัั ะฝะฐ ัะธะฝะณะต
rus_verbs:ัะฐัะฟะปัะฒะฐัััั{}, // ัะฐัะฟะปัะฒะฐัััั ะฝะฐ ะถะฐัะต
rus_verbs:ัะพััะธัะฐัั{}, // ัะพััะธัะฐัั ะฝะฐ ะฟะฐะปััะฐั
rus_verbs:ัะณัััะธัััั{}, // ัะณัััะธัััั ะฝะฐ ะฝะตะฑะพะปััะพะน ะฒััะพัะต
rus_verbs:ัะธัะธัะพะฒะฐัั{}, // ัะธัะธัะพะฒะฐัั ะฝะฐ ะฟะปะธัะต
rus_verbs:ะพัะธะตะฝัะธัะพะฒะฐัััั{}, // ะพัะธะตะฝัะธัะพะฒะฐัััั ะฝะฐ ะผะตััะฝะพััะธ
rus_verbs:ัะฐััะธัะธัั{}, // ัะฐััะธัะธัั ะฝะฐ ะดััะณะพะผ ะบะพะฝัะต
rus_verbs:ะพะฑัะตัะตัั{}, // ะพะฑัะตัะตัั ะฝะฐ ััะพัะฝะบะต
rus_verbs:ะฟะพะดัััะตะปะธัั{}, // ะฟะพะดัััะตะปะธัั ะฝะฐ ะพั
ะพัะต
rus_verbs:ัะฐััะตัะตัั{}, // ัะฐััะตัะตัั ะฝะฐ ัะฒะตัะดะพะน ะฟะพะฒะตัั
ะฝะพััะธ
rus_verbs:ะฟะพะดะฐะฒะปััั{}, // ะฟะพะดะฐะฒะปััั ะฝะฐ ะฟะตัะฒะพะผ ััะฐะฟะต
rus_verbs:ัะผะตัะธะฒะฐัััั{}, // ัะผะตัะธะฒะฐัััั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััะธ
// ะธะฝัะธะฝะธัะธะฒ:ะฒััะธัะฐัั{ aux stress="ะฒ^ััะธัะฐัั" }, ะณะปะฐะณะพะป:ะฒััะธัะฐัั{ aux stress="ะฒ^ััะธัะฐัั" }, // ะฒััะธัะฐัั ะฝะฐ ัะฐะนัะต
// ะดะตะตะฟัะธัะฐััะธะต:ะฒััะธัะฐะฒ{},
rus_verbs:ัะพะบัะฐัะธัััั{}, // ัะพะบัะฐัะธัััั ะฝะฐ ะฒัะพัะพะผ ััะฐะฟะต
rus_verbs:ะทะฐะฝะตัะฒะฝะธัะฐัั{}, // ะทะฐะฝะตัะฒะฝะธัะฐัั ะฝะฐ ัะบะทะฐะผะตะฝะต
rus_verbs:ัะพะฟัะธะบะพัะฝััััั{}, // ัะพะฟัะธะบะพัะฝััััั ะฝะฐ ััะฐััะต
rus_verbs:ะพะฑะพะทะฝะฐัะธัั{}, // ะพะฑะพะทะฝะฐัะธัั ะฝะฐ ะฟะปะฐะฝะต
rus_verbs:ะพะฑััะฐัััั{}, // ะพะฑััะฐัััั ะฝะฐ ะฟัะพะธะทะฒะพะดััะฒะต
rus_verbs:ัะฝะธะทะธัััั{}, // ัะฝะธะทะธัััั ะฝะฐ ะฑะพะปััะพะน ะฒััะพัะต
rus_verbs:ะฟัะพัััะดะธัััั{}, // ะฟัะพัััะดะธัััั ะฝะฐ ะฒะตััั
rus_verbs:ะฟะพะดะดะตัะถะธะฒะฐัััั{}, // ะฟะพะดะดะตัะถะธะฒะฐะตััั ะฝะฐ ะฒัััะตัะต
rus_verbs:ัะฟะปััั{}, // ัะฟะปััั ะฝะฐ ะปะพะดะพัะบะต
rus_verbs:ัะตะทะฒะธัััั{}, // ัะตะทะฒะธัััั ะฝะฐ ะฟะตัะพัะบะต
rus_verbs:ะฟะพะตัะทะฐัั{}, // ะฟะพะตัะทะฐัั ะฝะฐ ัะบะฐะผะตะตัะบะต
rus_verbs:ะฟะพั
ะฒะฐััะฐัััั{}, // ะฟะพั
ะฒะฐััะฐัััั ะฝะฐ ะฒัััะตัะต
rus_verbs:ะทะฝะฐะบะพะผะธัััั{}, // ะทะฝะฐะบะพะผะธัััั ะฝะฐ ััะพะบะต
rus_verbs:ะฟัะพะฟะปัะฒะฐัั{}, // ะฟัะพะฟะปัะฒะฐัั ะฝะฐ ะบะฐัะตัะต
rus_verbs:ะทะฐัะตััั{}, // ะทะฐัะตััั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะฟะพะดัะตะฟะธัั{}, // ะฟะพะดัะตะฟะธัั ะฝะฐ ะดะธัะบะพัะตะบะต
rus_verbs:ะพะฑััะบะฐัั{}, // ะพะฑััะบะฐัั ะฝะฐ ะฒั
ะพะดะต
rus_verbs:ะพะฟัะฐะฒะดะฐัััั{}, // ะพะฟัะฐะฒะดะฐัััั ะฝะฐ ััะดะต
rus_verbs:ัะฐัะบััะฒะฐัััั{}, // ัะฐัะบััะฒะฐัััั ะฝะฐ ััะตะฝะต
rus_verbs:ะพะดะตะฒะฐัััั{}, // ะพะดะตะฒะฐัััั ะฝะฐ ะฒะตัะตะฒะพะผ ััะฝะบะต
rus_verbs:ะทะฐัะฒะตัะธัััั{}, // ะทะฐัะฒะตัะธัััั ะฝะฐ ัะพัะพะณัะฐัะธัั
rus_verbs:ัะฟะพััะตะฑะปััััั{}, // ัะฟะพััะตะฑะปััััั ะฝะฐ ะฟัะธัะตัะฐะฑัะธะบะฐั
rus_verbs:ะณัะฐะฑะธัั{}, // ะณัะฐะฑะธัั ะฝะฐ ะฟัััััะต
rus_verbs:ะณะพะฝััั{}, // ะณะพะฝััั ะฝะฐ ะฟะพะฒััะตะฝะฝัั
ะพะฑะพัะพัะฐั
rus_verbs:ัะฐะทะฒะตะฒะฐัััั{}, // ัะฐะทะฒะตะฒะฐัััั ะฝะฐ ะดัะตะฒะบะต
rus_verbs:ะพัะฝะพะฒัะฒะฐัััั{}, // ะพัะฝะพะฒัะฒะฐัััั ะฝะฐ ะฑะตะทััะปะพะฒะฝัั
ัะฐะบัะฐั
rus_verbs:ะดะพะฟัะฐัะธะฒะฐัั{}, // ะดะพะฟัะฐัะธะฒะฐัั ะฝะฐ ะฑะฐะทะต
rus_verbs:ะฟัะพัะฐะฑะพัะฐัั{}, // ะฟัะพัะฐะฑะพัะฐัั ะฝะฐ ัััะพะนะบะต
rus_verbs:ัะพััะตะดะพัะพัะธัั{}, // ัะพััะตะดะพัะพัะธัั ะฝะฐ ะผะตััะต
rus_verbs:ัะพัะธะฝััั{}, // ัะพัะธะฝััั ะฝะฐ ั
ะพะดั
rus_verbs:ะฟะพะปะทะฐัั{}, // ะฟะพะปะทะฐัั ะฝะฐ ะบะฐะผะฝะต
rus_verbs:ัะฐัะบะธะฝััััั{}, // ัะฐัะบะธะฝััััั ะฝะฐ ะฟัััััะต
rus_verbs:ัััะฐะฒะฐัั{}, // ัััะฐะฒะฐัั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ัะบัะตะฟะธัั{}, // ัะบัะตะฟะธัั ะฝะฐ ะบะพะฝัะต
rus_verbs:ะพะฑัะฐะทะพะฒัะฒะฐัั{}, // ะพะฑัะฐะทะพะฒัะฒะฐัั ะฝะฐ ะพัะบัััะพะผ ะฒะพะทะดัั
ะต ะฒะทััะฒะพะพะฟะฐัะฝัั ัะผะตัั
rus_verbs:ะพะดะพะฑัััั{}, // ะพะดะพะฑัััั ะฝะฐ ัะปะพะฒะฐั
rus_verbs:ะฟัะธะณะพะฒะพัะธัั{}, // ะฟัะธะณะพะฒะพัะธัั ะฝะฐ ะทะฐัะตะดะฐะฝะธะธ ััะพะนะบะธ
rus_verbs:ัะตัะฝะตัั{}, // ัะตัะฝะตัั ะฝะฐ ัะฒะตัั
rus_verbs:ะณะฝััั{}, // ะณะฝััั ะฝะฐ ััะฐะฝะบะต
rus_verbs:ัะฐะทะผะตัะฐัััั{}, // ัะฐะทะผะตัะฐัััั ะฝะฐ ะฑะธัะถะต
rus_verbs:ัะพะพััะดะธัั{}, // ัะพะพััะดะธัั ะฝะฐ ะดะฐัะต
rus_verbs:ะฟะฐััะธัั{}, // ะฟะฐััะธัั ะฝะฐ ะปัะณั
rus_verbs:ัะพัะผะธัะพะฒะฐัััั{}, // ัะพัะผะธัะพะฒะฐัััั ะฝะฐ ะดะฝะต
rus_verbs:ัะฐะธัั{}, // ัะฐะธัั ะฝะฐ ะดะฝะต
rus_verbs:ะฟัะธะพััะฐะฝะพะฒะธัััั{}, // ะฟัะธะพััะฐะฝะพะฒะธัััั ะฝะฐ ัะตัะตะดะธะฝะต
rus_verbs:ัะพะฟัะฐัััั{}, // ัะพะฟัะฐัััั ะฝะฐ ะผะตััะต
rus_verbs:ะณัะพะผะธัั{}, // ะณัะพะผะธัั ะฝะฐ ะฟะพะดัััะฟะฐั
rus_verbs:ะฒััะธัะปะธัั{}, // ะฒััะธัะปะธัั ะฝะฐ ะฑัะผะฐะถะบะต
rus_verbs:ะทะฐะบะฐะทัะฒะฐัั{}, // ะทะฐะบะฐะทัะฒะฐัั ะฝะฐ ัะฐะนัะต
rus_verbs:ะพัััะตััะฒะธัั{}, // ะพัััะตััะฒะธัั ะฝะฐ ะฟัะฐะบัะธะบะต
rus_verbs:ะพะฑะพัะฝะพะฒะฐัััั{}, // ะพะฑะพัะฝะพะฒะฐัััั ะฝะฐ ะฒะตัั
ััะบะต
rus_verbs:ะฟััะฐัั{}, // ะฟััะฐัั ะฝะฐ ัะปะตะบััะธัะตัะบะพะผ ัััะปะต
rus_verbs:ัะพะฒะตััะธัััั{}, // ัะพะฒะตััะธัััั ะฝะฐ ะทะฐัะตะดะฐะฝะธะธ
rus_verbs:ัะฒะตัะฝััััั{}, // ัะฒะตัะฝััััั ะฝะฐ ะผะตะดะปะตะฝะฝะพะผ ะพะณะฝะต
rus_verbs:ะฟัะพะปะตัะฐัั{}, // ะฟัะพะปะตัะฐัั ะฝะฐ ะดะตะปััะฐะฟะปะฐะฝะต
rus_verbs:ัะฑััััั{}, // ัะฑััััั ะฝะฐ ัะฐะผะพะผ ะดะตะปะต
rus_verbs:ัะฐะทะณะพะฒะพัะธัััั{}, // ัะฐะทะณะพะฒะพัะธัััั ะฝะฐ ััะพะบะต
rus_verbs:ัะฐะทะฒะพัะฐัะธะฒะฐัััั{}, // ัะฐะทะฒะพัะฐัะธะฒะฐัััั ะฝะฐ ะฟะตัะตะบัะตััะบะต
rus_verbs:ะฟัะตะฟะพะดะฝะตััะธ{}, // ะฟัะตะฟะพะดะฝะตััะธ ะฝะฐ ะฑะปัะดะตัะบะต
rus_verbs:ะฝะฐะฟะตัะฐัะฐัั{}, // ะฝะฐะฟะตัะฐัะฐัั ะฝะฐ ะปะฐะทะตัะฝะธะบะต
rus_verbs:ะฟัะพัะฒะฐัั{}, // ะฟัะพัะฒะฐัั ะฝะฐ ะฟะตัะธัะตัะธะธ
rus_verbs:ัะฐัะบะฐัะธะฒะฐัััั{}, // ัะฐัะบะฐัะธะฒะฐัััั ะฝะฐ ะดะพัะบะต
rus_verbs:ะทะฐะดะตัะถะธะฒะฐัััั{}, // ะทะฐะดะตัะถะธะฒะฐัััั ะฝะฐ ััะฐััะต
rus_verbs:ัะณะพัะฐัั{}, // ัะณะพัะฐัั ะฝะฐ ะฒะตัะตัะธะฝะบะต
rus_verbs:ัะฐัะธัั{}, // ัะฐัะธัั ะฝะฐ ััะพะปะต
rus_verbs:ัะฒะตะปะธัะธะฒะฐัั{}, // ัะฒะตะปะธัะธะฒะฐัั ะฝะฐ ะฟะตัะฒะพะผ ััะฐะฟะต
rus_verbs:ัะตั
ะฝััััั{}, // ัะตั
ะฝััััั ะฝะฐ ััะฐัะพััะธ ะปะตั
rus_verbs:ัะฐััะฒะตััะธ{}, // ัะฐััะฒะตััะธ ะฝะฐ ะณััะดะบะต
rus_verbs:ะทะฐะบะธะฟะตัั{}, // ะทะฐะบะธะฟะตัั ะฝะฐ ะฟะปะธัะต
rus_verbs:ะฟะพะดะปะตัะตัั{}, // ะฟะพะดะปะตัะตัั ะฝะฐ ะฟะฐัะฐะฟะปะฐะฝะต
rus_verbs:ัััััั{}, // ัััััั ะฝะฐ ัะฒะฐะปะบะต
rus_verbs:ะดะพะฑะธัะฐัััั{}, // ะดะพะฑะธัะฐัััั ะฝะฐ ะฟะพะฟััะบะฐั
rus_verbs:ะฟัะพะดะตัะถะฐัััั{}, // ะฟัะพะดะตัะถะฐัััั ะฝะฐ ะฒะตััะธะฝะต
rus_verbs:ัะฐะทััะบะธะฒะฐัั{}, // ัะฐะทััะบะธะฒะฐัั ะฝะฐ ะฒัััะฐะฒะบะฐั
rus_verbs:ะพัะฒะพะฑะพะถะดะฐัั{}, // ะพัะฒะพะฑะพะถะดะฐัั ะฝะฐ ะทะฐัะตะดะฐะฝะธะธ
rus_verbs:ะฟะตัะตะดะฒะธะณะฐัััั{}, // ะฟะตัะตะดะฒะธะณะฐัััั ะฝะฐ ัะฐะผะพะบะฐัะต
rus_verbs:ะฟัะพัะฒะธัััั{}, // ะฟัะพัะฒะธัััั ะฝะฐ ัะฒะตัั
rus_verbs:ะทะฐัะบะพะปัะทะธัั{}, // ะทะฐัะบะพะปัะทะธัั ะฝะฐ ะปัะดั
rus_verbs:ะฟะตัะตัะบะฐะทะฐัั{}, // ะฟะตัะตัะบะฐะทะฐัั ะฝะฐ ััะตะฝะต ัััะดะตะฝัะตัะบะพะณะพ ัะตะฐััะฐ
rus_verbs:ะฟัะพัะตััะพะฒะฐัั{}, // ะฟัะพัะตััะพะฒะฐัั ะฝะฐ ัะปะธัะต
rus_verbs:ัะบะฐะทัะฒะฐัััั{}, // ัะบะฐะทัะฒะฐัััั ะฝะฐ ัะฐะฑะปะธัะบะฐั
rus_verbs:ะฟัะธัะบะฐะบะฐัั{}, // ะฟัะธัะบะฐะบะฐัั ะฝะฐ ะปะพัะฐะดะบะต
rus_verbs:ะบะพะฟะพัะธัััั{}, // ะบะพะฟะพัะธัััั ะฝะฐ ัะฒะตะถะตะผ ะฒะพะทะดัั
ะต
rus_verbs:ะฟะพะดััะธัะฐัั{}, // ะฟะพะดััะธัะฐัั ะฝะฐ ะฑัะผะฐะถะบะต
rus_verbs:ัะฐะทะฒะพะปะฝะพะฒะฐัััั{}, // ัะฐะทะฒะพะปะฝะพะฒะฐัััั ะฝะฐ ัะบะทะฐะผะตะฝะต
rus_verbs:ะทะฐะฒะตััะตัััั{}, // ะทะฐะฒะตััะตัััั ะฝะฐ ะฟะพะปั
rus_verbs:ะพะทะฝะฐะบะพะผะธัััั{}, // ะพะทะฝะฐะบะพะผะธัััั ะฝะฐ ั
ะพะดั
rus_verbs:ัะถะฐัั{}, // ัะถะฐัั ะฝะฐ ััะพะบะต
rus_verbs:ัะฐัะบะธะฝััั{}, // ัะฐัะบะธะฝััั ะฝะฐ ะณััะดะบะฐั
rus_verbs:ัะฐะทะณัะพะผะธัั{}, // ัะฐะทะณัะพะผะธัั ะฝะฐ ัะธะฝะณะต
rus_verbs:ะฟะพะดัะปััะฐัั{}, // ะฟะพะดัะปััะฐัั ะฝะฐ ัะพะฒะตัะฐะฝะธะธ
rus_verbs:ะพะฟะธััะฒะฐัััั{}, // ะพะฟะธััะฒะฐัััั ะฝะฐ ัััะฐะฝะธัะฐั
ะบะฝะธะณะธ
rus_verbs:ะบะฐัะฐัััั{}, // ะบะฐัะฐัััั ะฝะฐ ัััะปะต
rus_verbs:ััะธะปะธัั{}, // ััะธะปะธัั ะฝะฐ ัะปะฐะฝะณะฐั
rus_verbs:ะฝะฐะฑัะพัะฐัั{}, // ะฝะฐะฑัะพัะฐัั ะฝะฐ ะบะปะพัะบะต ะบะฐััะพะฝะฐ
rus_verbs:ัะฐััััะตะปะธะฒะฐัั{}, // ัะฐััััะตะปะธะฒะฐัั ะฝะฐ ะฟะพะดั
ะพะดะต
rus_verbs:ะทะฐะฟััะณะฐัั{}, // ะทะฐะฟััะณะฐัั ะฝะฐ ะพะดะฝะพะน ะฝะพะณะต
rus_verbs:ัััะบะฐัั{}, // ัััะบะฐัั ะฝะฐ ััะถะฑะธะฝะต
rus_verbs:ะฟะพะดัะฒะตัะดะธัััั{}, // ะฟะพะดัะฒะตัะดะธัััั ะฝะฐ ะฟัะฐะบัะธะบะต
rus_verbs:ะฟะปะตัะบะฐัััั{}, // ะฟะปะตัะบะฐัััั ะฝะฐ ะผะตะปะบะพะฒะพะดัะต
rus_verbs:ัะฐััะธัััััั{}, // ัะฐััะธัััััั ะฝะฐ ะบะพะฝัะต
rus_verbs:ะฟะพะดะตัะถะฐัั{}, // ะฟะพะดะตัะถะฐัั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะฟะปะฐะฝะธัะพะฒะฐัััั{}, // ะฟะปะฐะฝะธัะพะฒะฐัััั ะฝะฐ ะพะฑัะตะผ ัะพะฑัะฐะฝะธะธ
rus_verbs:ัะณะธะฝััั{}, // ัะณะธะฝััั ะฝะฐ ััะถะฑะธะฝะต
rus_verbs:ะทะฐะผะบะฝััััั{}, // ะทะฐะผะบะฝััััั ะฝะฐ ัะพัะบะต
rus_verbs:ะทะฐะบะฐัะฐัััั{}, // ะทะฐะบะฐัะฐัััั ะฝะฐ ะฒะตััั
rus_verbs:ะฟะตัะตัะธััะฒะฐัั{}, // ะฟะตัะตัะธััะฒะฐัั ะฝะฐ ั
ะพะดั
rus_verbs:ะฟะตัะตะปะตัะตัั{}, // ะฟะตัะตะปะตัะตัั ะฝะฐ ะดะตะปััะฐะฟะปะฐะฝะต
rus_verbs:ะพะถะธะฒะฐัั{}, // ะพะถะธะฒะฐัั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะถะตะฝะธัั{}, // ะถะตะฝะธัั ะฝะฐ ะฑะพะณะฐัะพะน ะฝะตะฒะตััะต
rus_verbs:ะทะฐะณะปะพั
ะฝััั{}, // ะทะฐะณะปะพั
ะฝััั ะฝะฐ ััะฐััะต
rus_verbs:ะบะพะฟะฐัััั{}, // ะบะพะฟะฐัััั ะฝะฐ ะฟะพะปั
rus_verbs:ัะฐะทะฒะปะตะบะฐัััั{}, // ัะฐะทะฒะปะตะบะฐัััั ะฝะฐ ะดะธัะบะพัะตะบะต
rus_verbs:ะฟะตัะฐัะฐัััั{}, // ะฟะตัะฐัะฐัััั ะฝะฐ ััััะนะฝะพะผ ะฟัะธะฝัะตัะต
rus_verbs:ะพะฑััะฒะฐัััั{}, // ะพะฑััะฒะฐัััั ะฝะฐ ะฟะพะปััะปะพะฒะต
rus_verbs:ััะบะฐะบะฐัั{}, // ััะบะฐะบะฐัั ะฝะฐ ะปะพัะฐะดะบะต
rus_verbs:ะฟะพะดะฟะธััะฒะฐัั{}, // ะฟะพะดะฟะธััะฒะฐัั ะฝะฐ ััะพะปะต
rus_verbs:ะดะพะฑัะฒะฐัั{}, // ะดะพะฑัะฒะฐัั ะฝะฐ ะฒััะฐะฑะพัะบะต
rus_verbs:ัะบะพะฟะธัััั{}, // ัะบะพะฟะธัััั ะฝะฐ ะฒัั
ะพะดะต
rus_verbs:ะฟะพะฒัััะตัะฐัั{}, // ะฟะพะฒัััะตัะฐัั ะฝะฐ ะฟััะธ
rus_verbs:ะฟะพัะตะปะพะฒะฐัััั{}, // ะฟะพัะตะปะพะฒะฐัััั ะฝะฐ ะฟะปะพัะฐะดะธ
rus_verbs:ัะฐัััะฝััั{}, // ัะฐัััะฝััั ะฝะฐ ััะพะปะต
rus_verbs:ะฟะพะดะฐะฒะฐัััั{}, // ะฟะพะดะฐะฒะฐัััั ะฝะฐ ะฑะปะฐะณะพัะฒะพัะธัะตะปัะฝะพะผ ะพะฑะตะดะต
rus_verbs:ะฟะพะฒัััะตัะฐัััั{}, // ะฟะพะฒัััะตัะฐัััั ะฝะฐ ะผะธัะธะฝะณะต
rus_verbs:ะฟัะธะผะพััะธัััั{}, // ะฟัะธะผะพััะธัััั ะฝะฐ ัััะฟะตะฝัะบะฐั
rus_verbs:ะพััะฐะทะธัั{}, // ะพััะฐะทะธัั ะฝะฐ ัััะฐะฝะธัะฐั
ะดะพะบะปะฐะดะฐ
rus_verbs:ะฟะพััะฝััั{}, // ะฟะพััะฝััั ะฝะฐ ัััะฐะฝะธัะฐั
ะฟัะธะปะพะถะตะฝะธั
rus_verbs:ะฝะฐะบะพัะผะธัั{}, // ะฝะฐะบะพัะผะธัั ะฝะฐ ะบัั
ะฝะต
rus_verbs:ะฟะพัะถะธะฝะฐัั{}, // ะฟะพัะถะธะฝะฐัั ะฝะฐ ะฒะตัะฐะฝะดะต
ะธะฝัะธะฝะธัะธะฒ:ัะฟะตัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฟะตัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะฟะตัั ะฝะฐ ะผะธัะธะฝะณะต
ะดะตะตะฟัะธัะฐััะธะต:ัะฟะตะฒ{},
ะธะฝัะธะฝะธัะธะฒ:ัะฟะตัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฟะตัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ัะพะฟะธัั{}, // ัะพะฟะธัั ะฝะฐ ะผะตะปะบะพะฒะพะดัะต
rus_verbs:ะพัะฒะพะธัั{}, // ะพัะฒะพะธัั ะฝะฐ ะฟัะฐะบัะธะบะต
rus_verbs:ัะฐัะฟะปะฐััะฐัััั{}, // ัะฐัะฟะปะฐััะฐัััั ะฝะฐ ััะฐะฒะบะต
rus_verbs:ะพัะฟะปััั{}, // ะพัะฟะปััั ะฝะฐ ััะฐัะพะผ ะบะฐัะบะต
rus_verbs:ัะปะตัะฐัั{}, // ัะปะตัะฐัั ะฝะฐ ะปัะฑะพะผ ัะฐะผะพะปะตัะต
rus_verbs:ะพัััะฐะธะฒะฐัั{}, // ะพัััะฐะธะฒะฐัั ะฝะฐ ะบะพััะต
rus_verbs:ะพััะถะดะฐัั{}, // ะพััะถะดะฐัั ะฝะฐ ัะปะพะฒะฐั
rus_verbs:ะฟะตัะตะณะพะฒะพัะธัั{}, // ะฟะตัะตะณะพะฒะพัะธัั ะฝะฐ ะพะฑะตะดะต
rus_verbs:ัะบัััั{}, // ัะบัััั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ัะพะผะธัััั{}, // ัะพะผะธัััั ะฝะฐ ะฟัะธะฒัะทะธ
rus_verbs:ัะถะธะณะฐัั{}, // ัะถะธะณะฐัั ะฝะฐ ะฟะพะปะธะณะพะฝะต
rus_verbs:ะฟะพะทะฐะฒััะฐะบะฐัั{}, // ะฟะพะทะฐะฒััะฐะบะฐัั ะฝะฐ ะปะพะฝะต ะฟัะธัะพะดั
rus_verbs:ััะฝะบัะธะพะฝะธัะพะฒะฐัั{}, // ััะฝะบัะธะพะฝะธััะตั ะฝะฐ ัะพะปะฝะตัะฝะพะน ัะฝะตัะณะธะธ
rus_verbs:ัะฐะทะผะตััะธัั{}, // ัะฐะทะผะตััะธัั ะฝะฐ ัะฐะนัะต
rus_verbs:ะฟัะพะฝะตััะธ{}, // ะฟัะพะฝะตััะธ ะฝะฐ ัะตะปะต
rus_verbs:ะฝะฐัะฐัะธัั{}, // ะฝะฐัะฐัะธัั ะฝะฐ ััะพะปะต
rus_verbs:ะบะพััะธัััั{}, // ะบะพััะธัััั ะฝะฐ ะฟะพะปั
rus_verbs:ัะฐัะฟะพะทะฝะฐัั{}, // ัะฐัะฟะพะทะฝะฐัั ะฝะฐ ัะฝะธะผะบะต
rus_verbs:ะฟะพะฒะตัะธัััั{}, // ะฟะพะฒะตัะธัััั ะฝะฐ ัะฝััะต
rus_verbs:ะพะฑะพะทะฝะฐัะธัััั{}, // ะพะฑะพะทะฝะฐัะธัััั ะฝะฐ ะบะฐััะฐั
rus_verbs:ะพัััะฟะธัััั{}, // ะพัััะฟะธัััั ะฝะฐ ัะบะพะปัะทะบะพะผ ะปัะดั
rus_verbs:ะฟะพะดะฝะพัะธัั{}, // ะฟะพะดะฝะพัะธัั ะฝะฐ ะฑะปัะดะตัะบะต
rus_verbs:ัะฐัััะตะปะธัั{}, // ัะฐัััะตะปะธัั ะฝะฐ ะณะฐะทะพะฝะต
rus_verbs:ะพะฑััะถะดะฐัััั{}, // ะพะฑััะถะดะฐัััั ะฝะฐ ัะพะฑัะฐะฝะธะธ
rus_verbs:ัะฐัะฟะธัะฐัััั{}, // ัะฐัะฟะธัะฐัััั ะฝะฐ ะฑะปะฐะฝะบะต
rus_verbs:ะฟะปะตััะธัั{}, // ะฟะปะตััะธัั ะฝะฐ ะฟัะธะฒัะทะธ
rus_verbs:ะพะฑััะฒะธัััั{}, // ะพะฑััะฒะธัััั ะฝะฐ ััะตะฝะต
rus_verbs:ะฟะพะฒััะฐัััั{}, // ะฟะพะฒััะฐัััั ะฝะฐ ะฟะตัะฒะพะผ ะดะฐััะธะบะต
rus_verbs:ัะฐะทัะฐะฑะฐััะฒะฐัั{}, // ัะฐะทัะฐะฑะฐััะฒะฐัั ะฝะฐ ะทะฐะฒะพะดะต
rus_verbs:ะฟัะตััะฒะฐัั{}, // ะฟัะตััะฒะฐัั ะฝะฐ ัะตัะตะดะธะฝะต
rus_verbs:ะบะฐััััั{}, // ะบะฐััััั ะฝะฐ ะฟัะฑะปะธะบะต
rus_verbs:ะพัะฒะพะธัััั{}, // ะพัะฒะพะธัััั ะฝะฐ ะปะพัะฐะดะธ
rus_verbs:ะฟะพะดะฟะปััั{}, // ะฟะพะดะฟะปััั ะฝะฐ ะฟะปะพัั
rus_verbs:ะพัะบะพัะฑะธัั{}, // ะพัะบะพัะฑะธัั ะฝะฐ ะผะธัะธะฝะณะต
rus_verbs:ัะพัะถะตััะฒะพะฒะฐัั{}, // ัะพัะถะตััะฒะพะฒะฐัั ะฝะฐ ะฟัะตะดะตััะฐะปะต
rus_verbs:ะฟะพะฟัะฐะฒะปััั{}, // ะฟะพะฟัะฐะฒะปััั ะฝะฐ ะพะดะตะถะดะต
rus_verbs:ะพััะฐะถะฐัั{}, // ะพััะฐะถะฐัั ะฝะฐ ะบะฐััะธะฝะต
rus_verbs:ะดัะตะผะฐัั{}, // ะดัะตะผะฐัั ะฝะฐ ะบััะตัะบะต
rus_verbs:ะฟัะธะผะตะฝััััั{}, // ะฟัะธะผะตะฝััััั ะฝะฐ ะฟัะพะธะทะฒะพะดััะฒะต ััะฐะปะธ
rus_verbs:ะฟะพัะฐะถะฐัั{}, // ะฟะพัะฐะถะฐัั ะฝะฐ ะฑะพะปััะพะน ะดะธััะฐะฝัะธะธ
rus_verbs:ัะฐััััะตะปััั{}, // ัะฐััััะตะปััั ะฝะฐ ะพะบัะฐะธะฝะต ั
ััะพัะฐ
rus_verbs:ัะฐัััะธัะฐัั{}, // ัะฐัััะธัะฐัั ะฝะฐ ะบะฐะปัะบัะปััะพัะต
rus_verbs:ะทะฐะฟะธััะฒะฐัั{}, // ะทะฐะฟะธััะฒะฐัั ะฝะฐ ะปะตะฝัะต
rus_verbs:ะฟะตัะตะฑะธัะฐัั{}, // ะฟะตัะตะฑะธัะฐัั ะฝะฐ ะปะฐะดะพะฝะธ
rus_verbs:ัะฐะทะฑะธัััั{}, // ัะฐะทะฑะธัััั ะฝะฐ ะบะฐัะตัะต
rus_verbs:ะฟะพะธัะบะฐัั{}, // ะฟะพะธัะบะฐัั ะฝะฐ ัะตัะผะต
rus_verbs:ะฟัััะฐัั{}, // ะฟัััะฐัั ะฝะฐ ะทะฐะฑัะพัะตะฝะฝะพะผ ัะบะปะฐะดะต
rus_verbs:ะฟัะพะฟะตัั{}, // ะฟัะพะฟะตัั ะฝะฐ ััััะฐะดะต
rus_verbs:ะทะฐะผะตะปัะบะฐัั{}, // ะทะฐะผะตะปัะบะฐัั ะฝะฐ ัะบัะฐะฝะต
rus_verbs:ะณััััะธัั{}, // ะณััััะธัั ะฝะฐ ะฒะตัะฐะฝะดะต
rus_verbs:ะบัััะธัั{}, // ะบัััะธัั ะฝะฐ ะพัะธ
rus_verbs:ะฟะพะดะณะพัะพะฒะธัั{}, // ะฟะพะดะณะพัะพะฒะธัั ะฝะฐ ะบะพะฝัะฟะธัะฐัะธะฒะฝะพะน ะบะฒะฐััะธัะต
rus_verbs:ัะฐะทะปะธัะฐัั{}, // ัะฐะทะปะธัะฐัั ะฝะฐ ะบะฐััะธะฝะบะต
rus_verbs:ะบะธัะฝััั{}, // ะบะธัะฝััั ะฝะฐ ััะถะฑะธะฝะต
rus_verbs:ะพะฑะพัะฒะฐัััั{}, // ะพะฑะพัะฒะฐัััั ะฝะฐ ะฟะพะปััะปะพะฒะต
rus_verbs:ะทะฐะฟััะฐัััั{}, // ะทะฐะฟััะฐัััั ะฝะฐ ะฟัะพััะตะนัะตะผ ัะตััะต
rus_verbs:ะพะฑัะฐัััั{}, // ะพะฑัะฐัััั ะฝะฐ ััะพะบะต
rus_verbs:ะฟัะพะธะทะฒะพะดะธัััั{}, // ะฟัะพะธะทะฒะพะดะธัััั ะฝะฐ ัะฐะฑัะธะบะต
rus_verbs:ัะพัะธะฝะธัั{}, // ัะพัะธะฝะธัั ะฝะฐ ะดะพััะณะต
rus_verbs:ะดะฐะฒะธัั{}, // ะดะฐะฒะธัั ะฝะฐ ะปะธัะต
rus_verbs:ัะฐะทัะฐะฑะพัะฐัั{}, // ัะฐะทัะฐะฑะพัะฐัั ะฝะฐ ัะตะบัะตัะฝะพะผ ะฟัะตะดะฟัะธััะธะธ
rus_verbs:ะบะฐัะฐัั{}, // ะบะฐัะฐัั ะฝะฐ ะบะฐัะตะปัั
rus_verbs:ัััะธัั{}, // ัััะธัั ะฝะฐ ะบัััะต ะฟะพะถะฐั
rus_verbs:ะพั
ัะฐะฝััั{}, // ะพั
ัะฐะฝััั ะฝะฐ ัะตััะธัะพัะธะธ ะฑะฐะทั
rus_verbs:ะฟัะธะผะตัะธัั{}, // ะฟัะธะผะตัะธัั ะฝะฐ ะฒะทะณะพัะบะต
rus_verbs:ัะบัััั{}, // ัะบัััั ะฝะฐ ัะตะปะต
rus_verbs:ัะดะตัะถะธะฒะฐัั{}, // ัะดะตัะถะธะฒะฐัั ะฝะฐ ััะบะต
rus_verbs:ััะฒะพะธัั{}, // ััะฒะพะธัั ะฝะฐ ััะพะบะต
rus_verbs:ัะฐััะฐััั{}, // ัะฐััะฐััั ะฝะฐ ัะพะปะฝะตัะฝะพะน ััะพัะพะฝะต
rus_verbs:ะบัะฐัะพะฒะฐัััั{}, // ะบัะฐัะพะฒะฐัััั ะฝะฐ ะฒะธะดั
rus_verbs:ัะพั
ัะฐะฝััััั{}, // ัะพั
ัะฐะฝััััั ะฝะฐ ั
ะพะปะพะดะต
rus_verbs:ะปะตัะธัั{}, // ะปะตัะธัั ะฝะฐ ะดะพะผั
rus_verbs:ะฟัะพะบะฐัะธัััั{}, // ะฟัะพะบะฐัะธัััั ะฝะฐ ัะฝะธัะธะบะปะต
rus_verbs:ะดะพะณะพะฒะฐัะธะฒะฐัััั{}, // ะดะพะณะพะฒะฐัะธะฒะฐัััั ะฝะฐ ะฝะตะนััะฐะปัะฝะพะน ัะตััะธัะพัะธะธ
rus_verbs:ะบะฐัะฝััััั{}, // ะบะฐัะฝััััั ะฝะฐ ะพะดะฝะพะน ะฝะพะณะต
rus_verbs:ะพะฟัะฑะปะธะบะพะฒะฐัั{}, // ะพะฟัะฑะปะธะบะพะฒะฐัั ะฝะฐ ัะฐะนัะต
rus_verbs:ะพััะฐะถะฐัััั{}, // ะพััะฐะถะฐัััั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััะธ ะฒะพะดั
rus_verbs:ะพะฑะตะดะฐัั{}, // ะพะฑะตะดะฐัั ะฝะฐ ะฒะตัะฐะฝะดะต
rus_verbs:ะฟะพัะธะดะตัั{}, // ะฟะพัะธะดะตัั ะฝะฐ ะปะฐะฒะพัะบะต
rus_verbs:ัะพะพะฑัะฐัััั{}, // ัะพะพะฑัะฐัััั ะฝะฐ ะพัะธัะธะฐะปัะฝะพะผ ัะฐะนัะต
rus_verbs:ัะฒะตััะธัััั{}, // ัะฒะตััะธัััั ะฝะฐ ะทะฐัะตะดะฐะฝะธะธ
rus_verbs:ะฝะพัะตะฒะฐัั{}, // ะฝะพัะตะฒะฐัั ะฝะฐ ะดะฐัะต
rus_verbs:ัะตะผะฝะตัั{}, // ัะตะผะฝะตัั ะฝะฐ ัะฒะตัั
rus_verbs:ะณะธะฑะฝััั{}, // ะณะธะฑะฝััั ะฝะฐ ัะตััะธัะพัะธะธ ะฟะพะปะธะณะพะฝะฐ
rus_verbs:ััะธะปะธะฒะฐัััั{}, // ััะธะปะธะฒะฐัััั ะฝะฐ ัะตััะธัะพัะธะธ ะพะบััะณะฐ
rus_verbs:ะฟัะพะถะธะฒะฐัั{}, // ะฟัะพะถะธะฒะฐัั ะฝะฐ ะดะฐัะต
rus_verbs:ะธััะปะตะดะพะฒะฐัั{}, // ะธััะปะตะดะพะฒะฐัั ะฝะฐ ะฑะพะปััะพะน ะณะปัะฑะธะฝะต
rus_verbs:ะพะฑะธัะฐัั{}, // ะพะฑะธัะฐัั ะฝะฐ ะณัะพะผะฐะดะฝะพะน ะณะปัะฑะธะฝะต
rus_verbs:ััะฐะปะบะธะฒะฐัััั{}, // ััะฐะปะบะธะฒะฐัััั ะฝะฐ ะฑะพะปััะพะน ะฒััะพัะต
rus_verbs:ัะฐะธัััั{}, // ัะฐะธัััั ะฝะฐ ะฑะพะปััะพะน ะณะปัะฑะธะฝะต
rus_verbs:ัะฟะฐัะฐัั{}, // ัะฟะฐัะฐัั ะฝะฐ ะฟะพะถะฐัะต
rus_verbs:ัะบะฐะทัะฒะฐัััั{}, // ัะบะฐะทัะฒะฐัััั ะฝะฐ ะพะฑัะตะผ ัะตะทัะปััะฐัะต
rus_verbs:ะทะฐะฑะปัะดะธัััั{}, // ะทะฐะฑะปัะดะธัััั ะฝะฐ ัััะพะนะบะต
rus_verbs:ะฟะพัะฐัะธัั{}, // ะฟะพัะฐัะธัั ะฝะฐ ะฟะพะปะบะฐั
rus_verbs:ะฟะปะฐะฝะธัะพะฒะฐัั{}, // ะฟะปะฐะฝะธัะพะฒะฐัั ะฝะฐ ะฑัะผะฐะณะต
rus_verbs:ัะฐะฝะธัั{}, // ัะฐะฝะธัั ะฝะฐ ะฟะพะปะธะณะพะฝะต
rus_verbs:ั
ะปะพะฟะฐัั{}, // ั
ะปะพะฟะฐัั ะฝะฐ ััะตะฝะต
rus_verbs:ะพัะฝะพะฒะฐัั{}, // ะพัะฝะพะฒะฐัั ะฝะฐ ะณะพัะต ะฝะพะฒัะน ะผะพะฝะฐััััั
rus_verbs:ะพัะฑะธัั{}, // ะพัะฑะธัั ะฝะฐ ััะพะปะต
rus_verbs:ะพััะธัะฐัั{}, // ะพััะธัะฐัั ะฝะฐ ะทะฐัะตะดะฐะฝะธะธ ะบะพะผะธััะธะธ
rus_verbs:ัััะพััั{}, // ัััะพััั ะฝะฐ ะฝะพะณะฐั
rus_verbs:ะพัะทัะฒะฐัััั{}, // ะพัะทัะฒะฐัััั ะฝะฐ ัััะฐะฝะธัะฐั
ะพััััะฐ
rus_verbs:ะฟัะธัะพัะผะพะทะธัั{}, // ะฟัะธัะพัะผะพะทะธัั ะฝะฐ ะพะฑะพัะธะฝะต
rus_verbs:ัะธัะฐัััั{}, // ัะธัะฐัััั ะฝะฐ ะปะธัะต
rus_verbs:ะทะฐะธะณัะฐัั{}, // ะทะฐะธะณัะฐัั ะฝะฐ ัะฐะบัะพัะพะฝะต
rus_verbs:ะทะฐะฒะธัะฝััั{}, // ะทะฐะฒะธัะฝััั ะฝะฐ ะธะณัะพะฒะพะน ะฟะปะพัะฐะดะบะต
rus_verbs:ัะพะทะฝะฐัััั{}, // ัะพะทะฝะฐัััั ะฝะฐ ะดะพะฟัะพัะต
rus_verbs:ะฒัััะฝััััั{}, // ะฒัััะฝััััั ะฝะฐ ะพัะฝะพะน ััะฐะฒะบะต
rus_verbs:ะฝะฐะฒะพะดะธัั{}, // ะฝะฐะฒะพะดะธัั ะฝะฐ ััะพะปะต ะฟะพััะดะพะบ
rus_verbs:ะฟะพะบะพะธัััั{}, // ะฟะพะบะพะธัััั ะฝะฐ ะบะปะฐะดะฑะธัะต
rus_verbs:ะทะฝะฐัะธัััั{}, // ะทะฝะฐัะธัััั ะฝะฐ ะฑะตะนะดะถะธะบะต
rus_verbs:ััะตั
ะฐัั{}, // ััะตั
ะฐัั ะฝะฐ ัะฐะฝะบะฐั
rus_verbs:ะฟะพะทะฝะฐะบะพะผะธัั{}, // ะฟะพะทะฝะฐะบะพะผะธัั ะฝะฐ ัะฒะฐะดัะฑะต
rus_verbs:ะทะฐะฒัะทะฐัั{}, // ะทะฐะฒัะทะฐัั ะฝะฐ ัะฟะธะฝะต
rus_verbs:ะณัะพั
ะฝััั{}, // ะณัะพั
ะฝััั ะฝะฐ ะฟะปะพัะฐะดะธ
rus_verbs:ัะฐะทัะตั
ะฐัััั{}, // ัะฐะทัะตั
ะฐัััั ะฝะฐ ัะทะบะพะน ะดะพัะพะณะต
rus_verbs:ััะพะปะฟะธัััั{}, // ััะพะปะฟะธัััั ะฝะฐ ะบััะปััะต
rus_verbs:ะฟะพัััััั{}, // ะฟะพัััััั ะฝะฐ ะฟะพะปะบะฐั
rus_verbs:ะพัะปะฐะฑะธัั{}, // ะพัะปะฐะฑะธัั ะฝะฐ ัะตะต
rus_verbs:ะพะฟัะฐะฒะดัะฒะฐัั{}, // ะพะฟัะฐะฒะดัะฒะฐัั ะฝะฐ ััะดะต
rus_verbs:ะพะฑะฝะฐััะถะธะฒะฐัััั{}, // ะพะฑะฝะฐััะถะธะฒะฐัััั ะฝะฐ ัะบะปะฐะดะต
rus_verbs:ัะฟะฐััะธัั{}, // ัะฟะฐััะธัั ะฝะฐ ะดะตัะตะฒะต
rus_verbs:ะฟัะตัะฒะฐัััั{}, // ะฟัะตัะฒะฐัััั ะฝะฐ ะฟะพะปััะปะพะฒะต
rus_verbs:ัััะพะธัััั{}, // ัััะพะธัััั ะฝะฐ ะฟัััััะต
rus_verbs:ะฟะพะทะฝะฐัั{}, // ะฟะพะทะฝะฐัั ะฝะฐ ะฟัะฐะบัะธะบะต
rus_verbs:ะฟััะตัะตััะฒะพะฒะฐัั{}, // ะฟััะตัะตััะฒะพะฒะฐัั ะฝะฐ ะฟะพะตะทะดะต
rus_verbs:ะฟะพะฑะตะถะดะฐัั{}, // ะฟะพะฑะตะถะดะฐัั ะฝะฐ ัะธะฝะณะต
rus_verbs:ัะฐััะผะฐััะธะฒะฐัััั{}, // ัะฐััะผะฐััะธะฒะฐัััั ะฝะฐ ะทะฐัะตะดะฐะฝะธะธ
rus_verbs:ะฟัะพะดะฐะฒะฐัััั{}, // ะฟัะพะดะฐะฒะฐัััั ะฝะฐ ะพัะบัััะพะผ ััะฝะบะต
rus_verbs:ัะฐะทะผะตััะธัััั{}, // ัะฐะทะผะตััะธัััั ะฝะฐ ะฑะฐะทะต
rus_verbs:ะทะฐะฒััั{}, // ะทะฐะฒััั ะฝะฐ ั
ะพะปะผะต
rus_verbs:ะฝะฐััะธะณะฝััั{}, // ะฝะฐััะธะณะฝััั ะฝะฐ ะพะบัะฐะธะฝะต
rus_verbs:ัะบัััััั{}, // ัะบัััััั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ัะฐัะฟะปะฐะบะฐัััั{}, // ัะฐัะฟะปะฐะบะฐัััั ะฝะฐ ะทะฐัะตะดะฐะฝะธะธ ะบะพะผะธััะธะธ
rus_verbs:ะทะฐะบะฐะฝัะธะฒะฐัั{}, // ะทะฐะบะฐะฝัะธะฒะฐัั ะฝะฐ ะฟะพัะปะตะดะฝะตะผ ะทะฐะดะฐะฝะธะธ
rus_verbs:ะฟัะพะปะตะถะฐัั{}, // ะฟัะพะปะตะถะฐัั ะฝะฐ ััะพะปะต
rus_verbs:ะณัะพะผะพะทะดะธัััั{}, // ะณัะพะผะพะทะดะธัััั ะฝะฐ ะฟะพะปั
rus_verbs:ะทะฐะผะตัะทะฝััั{}, // ะทะฐะผะตัะทะฝััั ะฝะฐ ะพัะบัััะพะผ ะฒะพะทะดัั
ะต
rus_verbs:ะฟะพัะบะพะปัะทะฝััััั{}, // ะฟะพัะบะพะปัะทะฝััััั ะฝะฐ ะปัะดั
rus_verbs:ัะฐัะบะฐัั{}, // ัะฐัะบะฐัั ะฝะฐ ัะฟะธะฝะต
rus_verbs:ะฟัะพัะผะฐััะธะฒะฐัั{}, // ะฟัะพัะผะฐััะธะฒะฐัั ะฝะฐ ัะฐะนัะต
rus_verbs:ะพะฑะดัะผะฐัั{}, // ะพะฑะดัะผะฐัั ะฝะฐ ะดะพััะณะต
rus_verbs:ะณะฐะดะฐัั{}, // ะณะฐะดะฐัั ะฝะฐ ะบะพัะตะนะฝะพะน ะณััะต
rus_verbs:ะพััะฐะฝะฐะฒะปะธะฒะฐัั{}, // ะพััะฐะฝะฐะฒะปะธะฒะฐัั ะฝะฐ ะฒัั
ะพะดะต
rus_verbs:ะพะฑะพะทะฝะฐัะฐัั{}, // ะพะฑะพะทะฝะฐัะฐัั ะฝะฐ ัััะฐะฝะธัะต
rus_verbs:ะดะพะปะตัะตัั{}, // ะดะพะปะตัะตัั ะฝะฐ ัะฟะพััะธะฒะฝะพะผ ะฑะฐะนะบะต
rus_verbs:ัะตัะฝะธัััั{}, // ัะตัะฝะธัััั ะฝะฐ ัะตัะดะฐัะบะต
rus_verbs:ั
ะพัะพะฝะธัั{}, // ั
ะพัะพะฝะธัั ะฝะฐ ัะฐััะฝะพะผ ะบะปะฐะดะฑะธัะต
rus_verbs:ัััะฐะฝะพะฒะธัััั{}, // ัััะฐะฝะพะฒะธัััั ะฝะฐ ัะณะต
rus_verbs:ะฟัะธะบะธะดัะฒะฐัั{}, // ะฟัะธะบะธะดัะฒะฐัั ะฝะฐ ะบะปะพัะบะต ะฑัะผะฐะณะธ
rus_verbs:ะทะฐัะฐะธัััั{}, // ะทะฐัะฐะธัััั ะฝะฐ ะดะตัะตะฒะต
rus_verbs:ัะฐะทะดะพะฑััั{}, // ัะฐะทะดะพะฑััั ะฝะฐ ัะบะปะฐะดะต
rus_verbs:ะฟะตัะตะฑัะพัะธัั{}, // ะฟะตัะตะฑัะพัะธัั ะฝะฐ ะฒะตััะพะปะตัะฐั
rus_verbs:ะทะฐั
ะฒะฐััะฒะฐัั{}, // ะทะฐั
ะฒะฐััะฒะฐัั ะฝะฐ ะฑะฐะทะต
rus_verbs:ัะบะฐะทะฐัััั{}, // ัะบะฐะทะฐัััั ะฝะฐ ะธัะพะณะพะฒัั
ะพัะตะฝะบะฐั
rus_verbs:ะฟะพะบะฐัะธะฒะฐัััั{}, // ะฟะพะบะฐัะธะฒะฐัััั ะฝะฐ ะฒะพะปะฝะฐั
rus_verbs:ะบัััะธัััั{}, // ะบัััะธัััั ะฝะฐ ะบัั
ะฝะต
rus_verbs:ะฟะพะผะตัะฐัััั{}, // ะฟะพะผะตัะฐัััั ะฝะฐ ะฟะพะปะบะต
rus_verbs:ะฟะธัะฐัััั{}, // ะฟะธัะฐัััั ะฝะฐ ะฟะพะผะพะนะบะต
rus_verbs:ะพัะดะพั
ะฝััั{}, // ะพัะดะพั
ะฝััั ะฝะฐ ะทะฐะณะพัะพะดะฝะพะน ะฒะธะปะปะต
rus_verbs:ะบะฐัะฐัััั{}, // ะบะฐัะฐัััั ะฝะฐ ะฒะตะปะธะบะต
rus_verbs:ะฟะพัะฐะฑะพัะฐัั{}, // ะฟะพัะฐะฑะพัะฐัั ะฝะฐ ัััะพะนะบะต
rus_verbs:ะพะณัะฐะฑะธัั{}, // ะพะณัะฐะฑะธัั ะฝะฐ ะฟัััััะต
rus_verbs:ะทะฐัะฐะฑะฐััะฒะฐัั{}, // ะทะฐัะฐะฑะฐััะฒะฐัั ะฝะฐ ะฑะธัะถะต
rus_verbs:ะฟัะตััะฟะตัั{}, // ะฟัะตััะฟะตัั ะฝะฐ ะฝะธะฒะต ะธัะบััััะฒะฐ
rus_verbs:ะทะฐะตัะทะฐัั{}, // ะทะฐะตัะทะฐัั ะฝะฐ ัััะปะต
rus_verbs:ัะฐะทัััะฝะธัั{}, // ัะฐะทัััะฝะธัั ะฝะฐ ะฟะพะปัั
rus_verbs:ะพััะตะบะฐะฝะธัั{}, // ะพััะตะบะฐะฝะธัั ะฝะฐ ะผะตะดะฝะพะน ะฟะปะฐััะธะฝะต
rus_verbs:ัะพัะณะพะฒะฐัั{}, // ัะพัะณะพะฒะฐัั ะฝะฐ ััะฝะบะต
rus_verbs:ะฟะพะบะพะปะตะฑะฐัััั{}, // ะฟะพะบะพะปะตะฑะฐัััั ะฝะฐ ะฟะพัะพะณะต
rus_verbs:ะฟัะธะบะธะฝััั{}, // ะฟัะธะบะธะฝััั ะฝะฐ ะฑัะผะฐะถะบะต
rus_verbs:ัะฐััะตัั{}, // ัะฐััะตัั ะฝะฐ ััะฟะพะผ ะบะพะฝัะต
rus_verbs:ะฟะพัะผะตััััั{}, // ะฟะพัะผะตััััั ะฝะฐ ะฟะตัะตะผะตะฝะบะต
rus_verbs:ะพััััั{}, // ะพััััั ะฝะฐ ะผะพัะพะทะฝะพะผ ะฒะพะทะดัั
ะต
rus_verbs:ะทะฐะฟะตัะตัััั{}, // ะทะฐะฟะตัะตัััั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะพะฑะพะณะฝะฐัั{}, // ะพะฑะพะณะฝะฐัั ะฝะฐ ะฟะพะฒะพัะพัะต
rus_verbs:ะฟะพะดััะฝััััั{}, // ะฟะพะดััะฝััััั ะฝะฐ ัััะฝะธะบะต
rus_verbs:ะฟัะธะฒะพะทะธัั{}, // ะฟัะธะฒะพะทะธัั ะฝะฐ ะผะฐัะธะฝะต
rus_verbs:ะฟะพะดะฑะธัะฐัั{}, // ะฟะพะดะฑะธัะฐัั ะฝะฐ ะฟะพะปั
rus_verbs:ัะฝะธััะพะถะฐัั{}, // ัะฝะธััะพะถะฐัั ะฝะฐ ะฟะพะดั
ะพะดะต
rus_verbs:ะฟัะธัะฐะธัััั{}, // ะฟัะธัะฐะธัััั ะฝะฐ ะฒะตััะธะฝะต
rus_verbs:ะฟะปััะฐัั{}, // ะฟะปััะฐัั ะฝะฐ ะบะพัััั
rus_verbs:ะฟะพะดะถะธะดะฐัั{}, // ะฟะพะดะถะธะดะฐัั ะฝะฐ ะฒะพะบะทะฐะปะต
rus_verbs:ะทะฐะบะพะฝัะธัั{}, // ะั ะทะฐะบะพะฝัะธะปะธ ะธะณัั ะฝะฐ ัะฐะผะพะผ ะธะฝัะตัะตัะฝะพะผ ะผะตััะต (ะกะะ ะฝะต ะผะพะถะตั ะฑััั ะฟะตัะฒัะผ ะฟัะธะปะฐะณะฐัะตะปัะฝัะผ ะฒ ัะตะฟะพัะบะต!)
rus_verbs:ัะผะตะฝะธัััั{}, // ัะผะตะฝะธัััั ะฝะฐ ะฟะพััั
rus_verbs:ะฟะพััะธัะฐัั{}, // ะฟะพััะธัะฐัั ะฝะฐ ะฟะฐะปััะฐั
rus_verbs:ะฟัะธัะตะปะธัััั{}, // ะฟัะธัะตะปะธัััั ะฝะฐ ะฑะตะณั
rus_verbs:ะฝะฐัะธัะพะฒะฐัั{}, // ะฝะฐัะธัะพะฒะฐัั ะฝะฐ ััะตะฝะต
rus_verbs:ะฟััะณะฐัั{}, // ะฟััะณะฐัั ะฝะฐ ััะตะฝะต
rus_verbs:ะฟะพะฒะตััะตัั{}, // ะฟะพะฒะตััะตัั ะฝะฐ ะฟะฐะปััะต
rus_verbs:ะฟะพะฟัะพัะฐัััั{}, // ะฟะพะฟัะพัะฐัััั ะฝะฐ ะฟะฐะฝะธั
ะธะดะต
ะธะฝัะธะฝะธัะธะฒ:ะฟัะพััะฟะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฟัะพััะฟะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, // ะฟัะพััะฟะฐัััั ะฝะฐ ะดะธะฒะฐะฝะต
rus_verbs:ัะฐะทะพะฑัะฐัั{}, // ัะฐะทะพะฑัะฐัั ะฝะฐ ััะพะปะต
rus_verbs:ะฟะพะผะตัะตัั{}, // ะฟะพะผะตัะตัั ะฝะฐ ััะถะฑะธะฝะต
rus_verbs:ัะฐะทะปะธัะธัั{}, // ัะฐะทะปะธัะธัั ะฝะฐ ะฝะตัะตัะบะพะน ัะพัะพะณัะฐัะธะธ
rus_verbs:ัะธัะพะฒะฐัั{}, // ัะธัะพะฒะฐัั ะฝะฐ ะดะพัะบะต
rus_verbs:ะฟัะพัะปะตะดะธัั{}, // ะฟัะพัะปะตะดะธัั ะฝะฐ ัะบัะฐะฝะต
rus_verbs:ะทะฐะดัะตะผะฐัั{}, // ะทะฐะดัะตะผะฐัั ะฝะฐ ะดะธะฒะฐะฝะต
rus_verbs:ััะณะฐัััั{}, // ััะณะฐัััั ะฝะฐ ะปัะดัั
rus_verbs:ัะณะพัะตัั{}, // ัะณะพัะตัั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ะทะฐะทะฒััะฐัั{}, // ะทะฐะทะฒััะฐัั ะฝะฐ ะบะพัะพัะบะธั
ะฒะพะปะฝะฐั
rus_verbs:ะทะฐะดะพั
ะฝััััั{}, // ะทะฐะดะพั
ะฝััััั ะฝะฐ ะฒะตััะธะฝะต ะณะพัั
rus_verbs:ะฟะพัะพะถะดะฐัั{}, // ะฟะพัะพะถะดะฐัั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััะธ ะฝะตะฑะพะปัััั ััะฑั
rus_verbs:ะพัะดัั
ะฐัั{}, // ะพัะดัั
ะฐัั ะฝะฐ ะบััะพััะต
rus_verbs:ะพะฑัะฐะทะพะฒะฐัั{}, // ะพะฑัะฐะทะพะฒะฐัั ะฝะฐ ะดะฝะต ัะพะปัััะน ัะปะพะน
rus_verbs:ะฟะพะฟัะฐะฒะธัััั{}, // ะฟะพะฟัะฐะฒะธัััั ะฝะฐ ะดะฐัะผะพะฒัั
ั
ะฐััะฐั
rus_verbs:ะพัะผะตัะฐัั{}, // ะพัะผะตัะฐัั ะฝะฐ ะบะฐะปะตะฝะดะฐัะต
rus_verbs:ัะตััั{}, // ัะตััั ะฝะฐ ัะปะฐะณััะพะบะต
rus_verbs:ะฟะพะปะทัะธ{}, // ะฟะพะปะทัะธ ะฝะฐ ะบะพะปะตะฝัั
rus_verbs:ะฟัะพะดะฐะฒะฐัั{}, // ะฟัะพะดะฐะฒะฐัั ะฝะฐ ะฐัะบัะธะพะฝะต
rus_verbs:ัะพััะตะดะพัะพัะธัััั{}, // ัะพััะตะดะพัะพัะธัััั ะฝะฐ ะพัะฝะพะฒะฝะพะน ะทะฐะดะฐัะต
rus_verbs:ัััะบะฐัั{}, // ะผััะบะธ ัััะบะฐะปะธ ะฝะฐ ะบัั
ะฝะต
rus_verbs:ัะฐัััะตะณะฝััั{}, // ัะฐัััะตะณะฝััั ะฝะฐ ะบัััะบะต ะฒัะต ะฟัะณะพะฒะธัั
rus_verbs:ะฝะฐะฟะฐััั{}, // ะฝะฐะฟะฐััั ะฝะฐ ัะตััะธัะพัะธะธ ะดััะณะพะณะพ ะณะพััะดะฐัััะฒะฐ
rus_verbs:ะธะทะดะฐัั{}, // ะธะทะดะฐัั ะฝะฐ ะทะฐะฟะฐะดะต
rus_verbs:ะพััะฐะฒะฐัััั{}, // ะพััะฐะฒะฐัััั ะฝะฐ ัััะฐะถะต ะฟะพััะดะบะฐ
rus_verbs:ะฟะพัะฒะธัััั{}, // ะฝะฐะบะพะฝะตั ะฟะพัะฒะธัััั ะฝะฐ ัะบัะฐะฝะต
rus_verbs:ะปะตะถะฐัั{}, // ะปะตะถะฐัั ะฝะฐ ััะพะปะต
rus_verbs:ะถะดะฐัั{}, // ะถะดะฐัั ะฝะฐ ะฑะตัะตะณั
ะธะฝัะธะฝะธัะธะฒ:ะฟะธัะฐัั{aux stress="ะฟะธั^ะฐัั"}, // ะฟะธัะฐัั ะฝะฐ ะฑัะผะฐะณะต
ะณะปะฐะณะพะป:ะฟะธัะฐัั{aux stress="ะฟะธั^ะฐัั"},
rus_verbs:ะพะบะฐะทัะฒะฐัััั{}, // ะพะบะฐะทัะฒะฐัััั ะฝะฐ ะฟะพะปั
rus_verbs:ะฟะพััะฐะฒะธัั{}, // ะฟะพััะฐะฒะธัั ะฝะฐ ััะพะปะต
rus_verbs:ะดะตัะถะฐัั{}, // ะดะตัะถะฐัั ะฝะฐ ะบัััะบะต
rus_verbs:ะฒัั
ะพะดะธัั{}, // ะฒัั
ะพะดะธัั ะฝะฐ ะพััะฐะฝะพะฒะบะต
rus_verbs:ะทะฐะณะพะฒะพัะธัั{}, // ะทะฐะณะพะฒะพัะธัั ะฝะฐ ะบะธัะฐะนัะบะพะผ ัะทัะบะต
rus_verbs:ะพะถะธะดะฐัั{}, // ะพะถะธะดะฐัั ะฝะฐ ััะพัะฝะบะต
rus_verbs:ะทะฐะบัะธัะฐัั{}, // ะทะฐะบัะธัะฐะป ะฝะฐ ะผะธะฝะฐัะตัะต ะผััะดะทะธะฝ
rus_verbs:ะฟัะพััะพััั{}, // ะฟัะพััะพััั ะฝะฐ ะฟะพััั
rus_verbs:ะฟัะพะดะพะปะถะธัั{}, // ะฟัะพะดะพะปะถะธัั ะฝะฐ ะฟะตัะฒะพะผ ััะฐะถะต
rus_verbs:ะพัััะธัั{}, // ะพัััะธัั ะฝะฐ ัะตะฑะต ะฒะปะธัะฝะธะต ะบัะธะทะธัะฐ
rus_verbs:ัะพััะพััั{}, // ัะพััะพััั ะฝะฐ ััะตัะต
rus_verbs:ะณะพัะพะฒะธัััั{},
ะธะฝัะธะฝะธัะธะฒ:ะฐะบะบะปะธะผะฐัะธะทะธัะพะฒะฐัััั{ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะฐะปัะฟะธะฝะธััั ะณะพัะพะฒัััั ะฐะบะบะปะธะผะฐัะธะทะธัะพะฒะฐัััั ะฝะฐ ะฝะพะฒะพะน ะฒััะพัะต
ะณะปะฐะณะพะป:ะฐะบะบะปะธะผะฐัะธะทะธัะพะฒะฐัััั{ะฒะธะด:ะฝะตัะพะฒะตัั},
rus_verbs:ะฐัะตััะพะฒะฐัั{}, // ะณัะฐะฑะธัะตะปะธ ะฑัะปะธ ะฐัะตััะพะฒะฐะฝั ะฝะฐ ะผะตััะต ะฟัะตัััะฟะปะตะฝะธั
rus_verbs:ัั
ะฒะฐัะธัั{}, // ะณัะฐะฑะธัะตะปะธ ะฑัะปะธ ัั
ะฒะฐัะตะฝั ะฝะฐ ะผะตััะต ะฟัะตัััะฟะปะตะฝะธั
ะธะฝัะธะฝะธัะธะฒ:ะฐัะฐะบะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ะฒะทะฒะพะด ะฑัะป ะฐัะฐะบะพะฒะฐะฝ ะฝะฐ ะณัะฐะฝะธัะต
ะณะปะฐะณะพะป:ะฐัะฐะบะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐัะฐะบะพะฒะฐะฝะฝัะน{ ะฒะธะด:ัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐัะฐะบะพะฒะฐะฒัะธะน{ ะฒะธะด:ัะพะฒะตัั },
rus_verbs:ะฑะฐะทะธัะพะฒะฐัั{}, // ัััะฐะฝะพะฒะบะฐ ะฑัะดะตั ะฑะฐะทะธัะพะฒะฐะฝะฐ ะฝะฐ ะณัะฐะฝะธัะต
rus_verbs:ะฑะฐะทะธัะพะฒะฐัััั{}, // ัััะฐะฝะพะฒะบะฐ ะฑะฐะทะธััะตััั ะฝะฐ ะณัะฐะฝะธัะต
rus_verbs:ะฑะฐัะฐั
ัะฐัััั{}, // ะดะตัะธ ะฑะฐัะฐั
ัะฐะปะธัั ะฝะฐ ะผะตะปะบะพะฒะพะดัะต
rus_verbs:ะฑัะฐะบะพะฝัะตัะธัั{}, // ะั
ะพัะฝะธะบะธ ะฑัะฐะบะพะฝัะตัะธะปะธ ะฝะพััั ะฝะฐ ัะตะบะต
rus_verbs:ะฑัะฐะบะพะฝัะตัััะฒะพะฒะฐัั{}, // ะั
ะพัะฝะธะบะธ ะฝะพััั ะฑัะฐะบะพะฝัะตัััะฒะพะฒะฐะปะธ ะฝะฐ ัะตะบะต
rus_verbs:ะฑัะตะฝัะฐัั{}, // ะฟะฐัะตะฝั ััะพ-ัะพ ะฑัะตะฝัะฐะป ะฝะฐ ะณะธัะฐัะต
rus_verbs:ะฑัะตะฝัะบะฐัั{}, // ะฟะฐัะตะฝั ััะพ-ัะพ ะฑัะตะฝัะบะฐะตั ะฝะฐ ะณะธัะฐัะต
rus_verbs:ะฝะฐัะฐัั{}, // ะ ัะฝะพะบ ะฐะบัะธะน ะ ะค ะฝะฐัะฐะป ัะพัะณะธ ะฝะฐ ะพััะธัะฐัะตะปัะฝะพะน ัะตััะธัะพัะธะธ.
rus_verbs:ะฑัะบัะพะฒะฐัั{}, // ะะพะปะตัะฐ ะฑัะบัััั ะฝะฐ ะปัะดั
rus_verbs:ะฒะตััะตัััั{}, // ะะตะฟะพัะตะดะปะธะฒัะน ััะตะฝะธะบ ะผะฝะพะณะพ ะฒะตััะธััั ะฝะฐ ัััะปะต
rus_verbs:ะฒะทะฒะตััะธ{}, // ะะพะตั ะฒะทะฒะตะป ะฝะฐ ะพััะถะธะธ ะฟัะตะดะพั
ัะฐะฝะธัะตะปั
rus_verbs:ะฒะธะปััั{}, // ะะฐัะธะฝะฐ ัะธะปัะฝะพ ะฒะธะปัะปะฐ ะฝะฐ ะดะพัะพะณะต
rus_verbs:ะฒะธัะตัั{}, // ะฏะฑะปะพะบะพ ะฒะธัะธั ะฝะฐ ะฒะตัะบะต
rus_verbs:ะฒะพะทะปะตะถะฐัั{}, // ะฒะพะทะปะตะถะฐัั ะฝะฐ ะปะตะถะฐะฝะบะต
rus_verbs:ะฟะพะดะฝะธะผะฐัััั{}, // ะั ะฟะพะดะฝะธะผะฐะตะผัั ะฝะฐ ะปะธััะต
rus_verbs:ะฟะพะดะฝััััั{}, // ะั ะฟะพะดะฝะธะผะตะผัั ะฝะฐ ะปะธััะต
rus_verbs:ะฒะพััะตะดะฐัั{}, // ะะพะปั ะฒะพััะตะดะฐะตั ะฝะฐ ะปะพัะฐะดะธ
rus_verbs:ะฒะพััะธััั{}, // ะัะฝะฐ ะฒะพััะธัะปะฐ ะฝะฐ ะฝะตะฑะต
rus_verbs:ะฒะพัะฐัะธัััั{}, // ะะธั ะฒะพัะฐัะธะปัั ะฝะฐ ะฒัะตะน ะทะตะผะปะต
rus_verbs:ะฒะพัะฐัััััั{}, // ะะธั ะฒะพัะฐััะตััั ะฝะฐ ะฒัะตะน ะทะตะผะปะต
rus_verbs:ะฒัะฐัะฐัั{}, // ะฒัะฐัะฐัั ะฝะฐ ะฟะพััะต
rus_verbs:ะฒัะฐัะฐัััั{}, // ะฒัะฐัะฐัััั ะฝะฐ ะฟะพััะต
rus_verbs:ะฒัััะตัะธัั{}, // ะฒัััะตัะธัั ะดััะณะฐ ะฝะฐ ัะปะธัะต
rus_verbs:ะฒัััะตัะธัััั{}, // ะฒัััะตัะธัััั ะฝะฐ ะทะฐะฝััะธัั
rus_verbs:ะฒัััะตัะฐัั{}, // ะฒัััะตัะฐัั ะฝะฐ ะทะฐะฝััะธัั
rus_verbs:ะฒัะตะฑัะฒะฐัั{}, // ะฒัะตะฑัะฒะฐัั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ะฒัะตะทะถะฐัั{}, // ะฒัะตะทะถะฐัั ะฝะฐ ะฐะฒัะพะผะพะฑะธะปะต
rus_verbs:ะฒัะตั
ะฐัั{}, // ะฒัะตั
ะฐัั ะฝะฐ ะฐะฒัะพะผะพะฑะธะปะต
rus_verbs:ะฒัะณะพัะฐัั{}, // ัะบะฐะฝั ะฒัะณะพัะฐะตั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะฒัะณะพัะตัั{}, // ัะบะฐะฝั ะฒัะณะพัะตะปะฐ ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะฒัะณัะฐะฒะธัะพะฒะฐัั{}, // ะฒัะณัะฐะฒะธัะพะฒะฐัั ะฝะฐ ัะฐะฑะปะธัะบะต ะฝะฐะดะฟะธัั
rus_verbs:ะฒัะถะธัั{}, // ะฒัะถะธัั ะฝะฐ ะฝะตะพะฑะธัะฐะตะผะพะผ ะพัััะพะฒะต
rus_verbs:ะฒัะปะตะถะฐัััั{}, // ะฟะพะผะธะดะพัั ะฒัะปะตะถะฐะปะธัั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะฒัะปะตะถะธะฒะฐัััั{}, // ะฒัะปะตะถะธะฒะฐัััั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะฒัะผะตััะธัั{}, // ะฒัะผะตััะธัั ะฝะฐ ะบะพะผ-ัะพ ะทะปะพะฑั
rus_verbs:ะฒัะผะตัะฐัั{}, // ะฒัะผะตัะฐัั ะฝะฐ ะบะพะผ-ัะพ ัะฒะพะต ัะฐะทะดัะฐะถะตะฝะธะต
rus_verbs:ะฒัะผะตัะฐัััั{}, // ะฒัะผะตัะฐัััั ะฝะฐ ะบะพะผ-ัะพ
rus_verbs:ะฒััะฐัะธะฒะฐัั{}, // ะฒััะฐัะธะฒะฐัั ะฝะฐ ะณััะดะบะต ะฟะพะผะธะดะพัั
rus_verbs:ะฒััะฐัะธะฒะฐัััั{}, // ะฒััะฐัะธะฒะฐัััั ะฝะฐ ะณััะดะบะต
ะธะฝัะธะฝะธัะธะฒ:ะฒััะตะทะฐัั{ะฒะธะด:ัะพะฒะตัั}, // ะฒััะตะทะฐัั ะฝะฐ ะดะพัะบะต ะฝะฐะดะฟะธัั
ะณะปะฐะณะพะป:ะฒััะตะทะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะธะฝัะธะฝะธัะธะฒ:ะฒััะตะทะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฒััะตะทะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
rus_verbs:ะฒััะธัะพะฒะฐัััั{}, // ะฒััะธัะพะฒะฐัััั ะฝะฐ ะณัะฐัะธะบะต
rus_verbs:ะฒััะธัะพะฒัะฒะฐัััั{}, // ะฒััะธัะพะฒัะฒะฐัััั ะฝะฐ ะณัะฐัะธะบะต
rus_verbs:ะฒััะฐะถะธะฒะฐัั{}, // ะฒััะฐะถะธะฒะฐัั ะฝะฐ ะฝะตะพะฑะธัะฐะตะผะพะผ ะพัััะพะฒะต
rus_verbs:ะฒััะฐะถะธะฒะฐัััั{}, // ะฒััะฐะถะธะฒะฐัััั ะฝะฐ ะพัััะพะฒะต
rus_verbs:ะฒััะฒะตัะธะฒะฐัั{}, // ะฒััะฒะตัะธะฒะฐัั ะฝะฐ ะดะธัะฟะปะตะต ัะตะผะฟะตัะฐัััั
rus_verbs:ะฒััะฒะตัะธะฒะฐัััั{}, // ะฒััะฒะตัะธะฒะฐัััั ะฝะฐ ะดะธัะฟะปะตะต
rus_verbs:ะฒััััะพะธัั{}, // ะฒััััะพะธัั ะฝะฐ ััะฝะดะฐะผะตะฝัะต
rus_verbs:ะฒััััะพะธัััั{}, // ะฒััััะพะธัััั ะฝะฐ ะฟะปะฐัั
rus_verbs:ะฒััััะดะธัั{}, // ะฒััััะดะธัั ะฝะฐ ะผะพัะพะทะต
rus_verbs:ะฒััััะดะธัััั{}, // ะฒััััะดะธัััั ะฝะฐ ะผะพัะพะทะต
rus_verbs:ะฒััััะถะฐัั{}, // ะฒััััะถะฐัั ะฝะฐ ะผะพัะพะทะต
rus_verbs:ะฒััััะถะธะฒะฐัั{}, // ะฒััััะถะธะฒะฐัั ะฝะฐ ะผะพัะพะทะต
rus_verbs:ะฒััััะถะธะฒะฐัััั{}, // ะฒััััะถะธะฒะฐัััั ะฝะฐ ะผะพัะพะทะต
rus_verbs:ะฒััััะบะฐัั{}, // ะฒััััะบะฐัั ะฝะฐ ะบะปะฐะฒะธะฐัััะต
rus_verbs:ะฒััััะบะธะฒะฐัั{}, // ะฒััััะบะธะฒะฐัั ะฝะฐ ะบะปะฐะฒะธะฐัััะต
rus_verbs:ะฒััััะบะธะฒะฐัััั{}, // ะฒััััะบะธะฒะฐัััั ะฝะฐ ะบะปะฐะฒะธะฐัััะต
rus_verbs:ะฒััััะฟะฐัั{}, // ะฒััััะฟะฐัั ะฝะฐ ััะตะฝะต
rus_verbs:ะฒััััะฟะธัั{}, // ะฒััััะฟะธัั ะฝะฐ ััะตะฝะต
rus_verbs:ะฒัััััะฐัั{}, // ะฒัััััะฐัั ะฝะฐ ะบะปะฐะฒะธะฐัััะต
rus_verbs:ะฒััััะฒะฐัั{}, // ะฒััััะฒะฐัั ะฝะฐ ะผะพัะพะทะต
rus_verbs:ะฒัััััั{}, // ะฒัััััั ะฝะฐ ะผะพัะพะทะต
rus_verbs:ะฒััะฐััะธัะพะฒะฐัั{}, // ะฒััะฐััะธัะพะฒะฐัั ะฝะฐ ััะบะต ัะบะพัั
rus_verbs:ะณะพะฒะพัะธัั{}, // ะณะพะฒะพัะธัั ะฝะฐ ะฟะพะฒััะตะฝะฝัั
ัะพะฝะฐั
rus_verbs:ะทะฐะผะตัะธัั{}, // ะทะฐะผะตัะธัั ะฝะฐ ะฑะตัะตะณั
rus_verbs:ััะพััั{}, // ัะฒััะดะพ ััะพััั ะฝะฐ ะฝะพะณะฐั
rus_verbs:ะพะบะฐะทะฐัััั{}, // ะพะบะฐะทะฐัััั ะฝะฐ ะฟะตัะตะดะพะฒะพะน ะปะธะฝะธะธ
rus_verbs:ะฟะพััะฒััะฒะพะฒะฐัั{}, // ะฟะพััะฒััะฒะพะฒะฐัั ะฝะฐ ัะฒะพะตะน ัะบััะต
rus_verbs:ะพััะฐะฝะพะฒะธัััั{}, // ะพััะฐะฝะพะฒะธัััั ะฝะฐ ะฟะตัะฒะพะผ ะฟัะฝะบัะต
rus_verbs:ะฟะพะบะฐะทะฐัััั{}, // ะฟะพะบะฐะทะฐัััั ะฝะฐ ะณะพัะธะทะพะฝัะต
rus_verbs:ััะฒััะฒะพะฒะฐัั{}, // ััะฒััะฒะพะฒะฐัั ะฝะฐ ัะฒะพะตะน ัะบััะต
rus_verbs:ะธัะบะฐัั{}, // ะธัะบะฐัั ะฝะฐ ะพัะบัััะพะผ ะฟัะพัััะฐะฝััะฒะต
rus_verbs:ะธะผะตัััั{}, // ะธะผะตัััั ะฝะฐ ัะบะปะฐะดะต
rus_verbs:ะบะปัััััั{}, // ะบะปัััััั ะฝะฐ ะะพัะฐะฝะต
rus_verbs:ะฟัะตัะฒะฐัั{}, // ะฟัะตัะฒะฐัั ะฝะฐ ะฟะพะปััะปะพะฒะต
rus_verbs:ะธะณัะฐัั{}, // ะธะณัะฐัั ะฝะฐ ััะฒััะฒะฐั
rus_verbs:ัะฟัััะธัััั{}, // ัะฟัััะธัััั ะฝะฐ ะฟะฐัะฐัััะต
rus_verbs:ะฟะพะฝะฐะดะพะฑะธัััั{}, // ะฟะพะฝะฐะดะพะฑะธัััั ะฝะฐ ัะบะทะฐะผะตะฝะต
rus_verbs:ัะปัะถะธัั{}, // ัะปัะถะธัั ะฝะฐ ัะปะพัะต
rus_verbs:ะฟะพะดะพะฑัะฐัั{}, // ะฟะพะดะพะฑัะฐัั ะฝะฐ ัะปะธัะต
rus_verbs:ะฟะพัะฒะปััััั{}, // ะฟะพัะฒะปััััั ะฝะฐ ััะตะฝะต
rus_verbs:ัะตะปะธัั{}, // ัะตะปะธัั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะฟะพะนะผะฐัั{}, // ะฟะพะนะผะฐัั ะฝะฐ ะณัะฐะฝะธัะต
rus_verbs:ัะฒะธะดะฐัั{}, // ัะฒะธะดะฐัั ะฝะฐ ะพะฟััะบะต
rus_verbs:ะฟะพะดะพะถะดะฐัั{}, // ะฟะพะดะพะถะดะฐัั ะฝะฐ ะฟะตััะพะฝะต
rus_verbs:ะฟัะพัะตััั{}, // ะฟัะพัะตััั ะฝะฐ ะฟะพะปัั
rus_verbs:ัะพะฝััั{}, // ัะพะฝััั ะฝะฐ ะผะตะปะบะพะฒะพะดัะต
rus_verbs:ะพัััะฐัั{}, // ะพัััะฐัั ะฝะฐ ะบะพะถะต
rus_verbs:ะพัะผะตัะธัั{}, // ะพัะผะตัะธัั ะฝะฐ ะฟะพะปัั
rus_verbs:ะฟะพะบะฐะทัะฒะฐัั{}, // ะฟะพะบะฐะทัะฒะฐัั ะฝะฐ ะณัะฐัะธะบะต
rus_verbs:ัะฐะทะณะพะฒะฐัะธะฒะฐัั{}, // ัะฐะทะณะพะฒะฐัะธะฒะฐัั ะฝะฐ ะธะฝะพัััะฐะฝะฝะพะผ ัะทัะบะต
rus_verbs:ะฟัะพัะธัะฐัั{}, // ะฟัะพัะธัะฐัั ะฝะฐ ัะฐะนัะต
rus_verbs:ะฟะพะฟัะพะฑะพะฒะฐัั{}, // ะฟะพะฟัะพะฑะพะฒะฐัั ะฝะฐ ะฟัะฐะบัะธะบะต
rus_verbs:ะทะฐะผะตัะฐัั{}, // ะทะฐะผะตัะฐัั ะฝะฐ ะบะพะถะต ะณััะทั
rus_verbs:ะฝะตััะธ{}, // ะฝะตััะธ ะฝะฐ ะฟะปะตัะฐั
rus_verbs:ะฝะพัะธัั{}, // ะฝะพัะธัั ะฝะฐ ะณะพะปะพะฒะต
rus_verbs:ะณะพัะตัั{}, // ะณะพัะตัั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ะทะฐััััั{}, // ะทะฐััััั ะฝะฐ ะฟะพัะพะณะต
ะธะฝัะธะฝะธัะธะฒ:ะถะตะฝะธัััั{ ะฒะธะด:ัะพะฒะตัั }, // ะถะตะฝะธัััั ะฝะฐ ะบะพัะพะปะตะฒะต
ะณะปะฐะณะพะป:ะถะตะฝะธัััั{ ะฒะธะด:ัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะถะตะฝะฐััะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะถะตะฝะธะฒัะธะนัั{},
rus_verbs:ัะฟัััะฐัั{}, // ัะฟัััะฐัั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ัะฐะทะฒะตัะฝััััั{}, // ัะฐะทะฒะตัะฝััััั ะฝะฐ ะฟะปะฐัั
rus_verbs:ัััะพะธัั{}, // ัััะพะธัั ะฝะฐ ะฟะตัะบะต
rus_verbs:ััััะพะธัั{}, // ััััะพะธัั ะฝะฐ ะดะฐัะต ัะตัััะฐะปัะฝัะน ะฒะตัะตั
rus_verbs:ะฝะฐััะฐะธะฒะฐัั{}, // ะฝะฐััะฐะธะฒะฐัั ะฝะฐ ะฒัะฟะพะปะฝะตะฝะธะธ ะฟัะธะบะฐะทะฐ
rus_verbs:ะฝะฐั
ะพะดะธัั{}, // ะฝะฐั
ะพะดะธัั ะฝะฐ ะฑะตัะตะณั
rus_verbs:ะผะตะปัะบะฝััั{}, // ะผะตะปัะบะฝััั ะฝะฐ ัะบัะฐะฝะต
rus_verbs:ะพัััะธัััั{}, // ะพัััะธัััั ะฝะฐ ะพะฟััะบะต ะปะตัะฐ
ะธะฝัะธะฝะธัะธะฒ:ะธัะฟะพะปัะทะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั}, // ะธัะฟะพะปัะทะพะฒะฐัั ะฝะฐ ัะฐะฑะพัะต
ะณะปะฐะณะพะป:ะธัะฟะพะปัะทะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะธะฝัะธะฝะธัะธะฒ:ะธัะฟะพะปัะทะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะธัะฟะพะปัะทะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะธัะฟะพะปัะทะพะฒะฐะฝะฝัะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะธัะฟะพะปัะทัััะธะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะธัะฟะพะปัะทะพะฒะฐะฒัะธะน{},
rus_verbs:ะปะตัะตัั{}, // ะปะตัะตัั ะฝะฐ ะฒะพะทะดััะฝะพะผ ัะฐัะต
rus_verbs:ัะผะตััััั{}, // ัะผะตััััั ะฝะฐ ััะตะฝะต
rus_verbs:ะตะทะดะธัั{}, // ะตะทะดะธัั ะฝะฐ ะผะพะฟะตะดะต
rus_verbs:ะทะฐัะฝััั{}, // ะทะฐัะฝััั ะฝะฐ ะดะธะฒะฐะฝะต
rus_verbs:ะทะฐััะฐัั{}, // ะทะฐััะฐัั ะฝะฐ ัะฐะฑะพัะตะผ ะผะตััะต
rus_verbs:ะพัะฝััััั{}, // ะพัะฝััััั ะฝะฐ ะฑะพะปัะฝะธัะฝะพะน ะบะพะนะบะต
rus_verbs:ัะฐะทะณะปัะดะตัั{}, // ัะฐะทะณะปัะดะตัั ะฝะฐ ัะพัะพะณัะฐัะธะธ
rus_verbs:ะพะฑะพะนัะธ{}, // ะพะฑะพะนัะธ ะฝะฐ ะฒะธัะฐะถะต
rus_verbs:ัะดะตัะถะฐัััั{}, // ัะดะตัะถะฐัััั ะฝะฐ ััะพะฝะต
rus_verbs:ะฟะพะฑัะฒะฐัั{}, // ะฟะพะฑัะฒะฐัั ะฝะฐ ะดััะณะพะน ะฟะปะฐะฝะตัะต
rus_verbs:ะทะฐะฝััััั{}, // ะทะฐะฝััััั ะฝะฐ ะฒัั
ะพะดะฝัั
ะดะตะปะพะผ
rus_verbs:ะฒัะฝััั{}, // ะฒัะฝััั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะฟะพััะพััั{}, // ะฟะพััะพััั ะฝะฐ ะณะพะปะพะฒะต
rus_verbs:ะฟัะธะพะฑัะตััะธ{}, // ะฟัะธะพะฑัะตััะธ ะฝะฐ ัะฐัะฟัะพะดะฐะถะต
rus_verbs:ะฟะพะฟะฐััััั{}, // ะฟะพะฟะฐััััั ะฝะฐ ะบัะฐะถะต
rus_verbs:ะฟัะพะดะพะปะถะฐัััั{}, // ะฟัะพะดะพะปะถะฐัััั ะฝะฐ ะทะตะผะปะต
rus_verbs:ะพัะบััะฒะฐัั{}, // ะพัะบััะฒะฐัั ะฝะฐ ะฐัะตะฝะต
rus_verbs:ัะพะทะดะฐะฒะฐัั{}, // ัะพะทะดะฐะฒะฐัั ะฝะฐ ััะตะฝะต
rus_verbs:ะพะฑััะถะดะฐัั{}, // ะพะฑััะถะดะฐัั ะฝะฐ ะบัั
ะฝะต
rus_verbs:ะพัััะบะฐัั{}, // ะพัััะบะฐัั ะฝะฐ ะฟะพะปั
rus_verbs:ััะฝััั{}, // ััะฝััั ะฝะฐ ะดะธะฒะฐะฝะต
rus_verbs:ะทะฐะดะตัะถะฐัััั{}, // ะทะฐะดะตัะถะฐัััั ะฝะฐ ัะฐะฑะพัะต
rus_verbs:ะบััะธัั{}, // ะบััะธัั ะฝะฐ ัะฒะตะถะตะผ ะฒะพะทะดัั
ะต
rus_verbs:ะฟัะธะฟะพะดะฝััััั{}, // ะฟัะธะฟะพะดะฝััััั ะฝะฐ ะปะพะบััั
rus_verbs:ัััะฐะฝะพะฒะธัั{}, // ัััะฐะฝะพะฒะธัั ะฝะฐ ะฒะตััะธะฝะต
rus_verbs:ะทะฐะฟะตัะตัั{}, // ะทะฐะฟะตัะตัั ะฝะฐ ะฑะฐะปะบะพะฝะต
rus_verbs:ัะธะฝะตัั{}, // ัะธะฝะตัั ะฝะฐ ะฒะพะทะดัั
ะต
rus_verbs:ัะฑะธะฒะฐัั{}, // ัะฑะธะฒะฐัั ะฝะฐ ะฝะตะนััะฐะปัะฝะพะน ัะตััะธัะพัะธะธ
rus_verbs:ัะบััะฒะฐัััั{}, // ัะบััะฒะฐัััั ะฝะฐ ะดะฐัะต
rus_verbs:ัะพะดะธัั{}, // ัะพะดะธัั ะฝะฐ ะฟะพะปั
rus_verbs:ะพะฟะธัะฐัั{}, // ะพะฟะธัะฐัั ะฝะฐ ัััะฐะฝะธัะฐั
ะบะฝะธะณะธ
rus_verbs:ะฟะตัะตั
ะฒะฐัะธัั{}, // ะฟะตัะตั
ะฒะฐัะธัั ะฝะฐ ะฟะพะดะปะตัะต
rus_verbs:ัะบััะฒะฐัั{}, // ัะบััะฒะฐัั ะฝะฐ ะดะฐัะต
rus_verbs:ัะผะตะฝะธัั{}, // ัะผะตะฝะธัั ะฝะฐ ะฟะพััั
rus_verbs:ะผะตะปัะบะฐัั{}, // ะผะตะปัะบะฐัั ะฝะฐ ัะบัะฐะฝะต
rus_verbs:ะฟัะธัััััะฒะพะฒะฐัั{}, // ะฟัะธัััััะฒะพะฒะฐัั ะฝะฐ ะผะตัะพะฟัะธััะธะธ
rus_verbs:ัะบัะฐััั{}, // ัะบัะฐััั ะฝะฐ ััะฝะบะต
rus_verbs:ะฟะพะฑะตะดะธัั{}, // ะฟะพะฑะตะดะธัั ะฝะฐ ัะธะฝะณะต
rus_verbs:ัะฟะพะผัะฝััั{}, // ัะฟะพะผัะฝััั ะฝะฐ ัััะฐะฝะธัะฐั
ัะพะผะฐะฝะฐ
rus_verbs:ะฟะปััั{}, // ะฟะปััั ะฝะฐ ััะฐัะพะน ะปะพะดะบะต
rus_verbs:ะฟะพะฒะธัะฝััั{}, // ะฟะพะฒะธัะฝััั ะฝะฐ ะฟะตัะตะบะปะฐะดะธะฝะต
rus_verbs:ะฝะฐััะฟะฐัั{}, // ะฝะฐััะฟะฐัั ะฝะฐ ะดะฝะต
rus_verbs:ะทะฐัะธั
ะฝััั{}, // ะทะฐัะธั
ะฝััั ะฝะฐ ะดะฝะต
rus_verbs:ะฟะพัััะพะธัั{}, // ะฟะพัััะพะธัั ะฝะฐ ััะฐััะบะต
rus_verbs:ะฟะพะดะดะตัะถะธะฒะฐัั{}, // ะฟะพะดะดะตัะถะธะฒะฐัั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััะธ
rus_verbs:ะทะฐัะฐะฑะพัะฐัั{}, // ะทะฐัะฐะฑะพัะฐัั ะฝะฐ ะฑะธัะถะต
rus_verbs:ะฟัะพะฒะฐะปะธัััั{}, // ะฟัะพะฒะฐะปะธัััั ะฝะฐ ัะบะทะฐะผะตะฝะต
rus_verbs:ัะพั
ัะฐะฝะธัั{}, // ัะพั
ัะฐะฝะธัั ะฝะฐ ะดะธัะบะต
rus_verbs:ัะฐัะฟะพะปะฐะณะฐัััั{}, // ัะฐัะฟะพะปะฐะณะฐัััั ะฝะฐ ัะพัะต
rus_verbs:ะฟะพะบะปัััััั{}, // ะฟะพะบะปัััััั ะฝะฐ ะฑะธะฑะปะธะธ
rus_verbs:ััะฐะถะฐัััั{}, // ััะฐะถะฐัััั ะฝะฐ ะฐัะตะฝะต
rus_verbs:ัะฟััะบะฐัััั{}, // ัะฟััะบะฐัััั ะฝะฐ ะดะตะปััะฐะฟะปะฐะฝะต
rus_verbs:ัะฝะธััะพะถะธัั{}, // ัะฝะธััะพะถะธัั ะฝะฐ ะฟะพะดัััะฟะฐั
rus_verbs:ะธะทััะธัั{}, // ะธะทััะธัั ะฝะฐ ะฟัะฐะบัะธะบะต
rus_verbs:ัะพะถะดะฐัััั{}, // ัะพะถะดะฐัััั ะฝะฐ ะฟัะฐะทะดะฝะธะบะฐั
rus_verbs:ะฟัะธะปะตัะตัั{}, // ะฟัะธะปะตัะตัั ะฝะฐ ัะฐะผะพะปะตัะต
rus_verbs:ะดะพะณะฝะฐัั{}, // ะดะพะณะฝะฐัั ะฝะฐ ะฟะตัะตะบัะตััะบะต
rus_verbs:ะธะทะพะฑัะฐะทะธัั{}, // ะธะทะพะฑัะฐะทะธัั ะฝะฐ ะฑัะผะฐะณะต
rus_verbs:ะฟัะพะตั
ะฐัั{}, // ะฟัะพะตั
ะฐัั ะฝะฐ ััะฐะบัะพัะต
rus_verbs:ะฟัะธะณะพัะพะฒะธัั{}, // ะฟัะธะณะพัะพะฒะธัั ะฝะฐ ะผะฐัะปะต
rus_verbs:ัะฟะพัะบะฝััััั{}, // ัะฟะพัะบะฝััััั ะฝะฐ ะฟะพะปั
rus_verbs:ัะพะฑะธัะฐัั{}, // ัะพะฑะธัะฐัั ะฝะฐ ะฑะตัะตะณั
rus_verbs:ะพััััััะฒะพะฒะฐัั{}, // ะพััััััะฒะพะฒะฐัั ะฝะฐ ัััะพะฒะบะต
rus_verbs:ะฟัะธะทะตะผะปะธัััั{}, // ะฟัะธะทะตะผะปะธัััั ะฝะฐ ะฒะพะตะฝะฝะพะผ ะฐััะพะดัะพะผะต
rus_verbs:ััะณัะฐัั{}, // ััะณัะฐัั ะฝะฐ ัััะฑะต
rus_verbs:ะฟัััะฐัััั{}, // ะฟัััะฐัััั ะฝะฐ ะดะฐัะต
rus_verbs:ัะฟัััะฐัััั{}, // ัะฟัััะฐัััั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะฟัะพะฒะพะทะณะปะฐัะธัั{}, // ะฟัะพะฒะพะทะณะปะฐัะธัั ะฝะฐ ะผะธัะธะฝะณะต
rus_verbs:ะธะทะปะพะถะธัั{}, // ะธะทะปะพะถะธัั ะฝะฐ ะฑัะผะฐะณะต
rus_verbs:ะธัะฟะพะปัะทะพะฒะฐัััั{}, // ะธัะฟะพะปัะทะพะฒะฐัััั ะฝะฐ ะฟัะฐะบัะธะบะต
rus_verbs:ะทะฐะผััััั{}, // ะทะฐะผััััั ะฝะฐ ะฒั
ะพะดะต
rus_verbs:ัะฐะทะดะฐะฒะฐัััั{}, // ะัะธะบ ัะณัะฐัะฐ ัะฐะทะดะฐะตััั ะฝะฐ ะบัะฐั ะฑะพะปะพัะฐ
rus_verbs:ัะฒะตัะบะฝััั{}, // ัะฒะตัะบะฝััั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ัะฒะตัะบะฐัั{}, // ัะฒะตัะบะฐัั ะฝะฐ ัะฒะตัั
rus_verbs:ะทะฐะดะตัะถะฐัั{}, // ะทะฐะดะตัะถะฐัั ะฝะฐ ะผะธัะธะฝะณะต
rus_verbs:ะพัะตัััั{}, // ะพัะตัััั ะฝะฐ ะฟะตัะฒะพะผ ัะปะพะฒะต
rus_verbs:ั
ัะฐะฝะธัั{}, // ั
ัะฐะฝะธัั ะฝะฐ ะฑะฐะฝะบะพะฒัะบะพะผ ััะตัั
rus_verbs:ัััะธัั{}, // ัััะธัั ะฝะฐ ััะพะบะต
rus_verbs:ะบััะถะธัััั{}, // ะบััะถะธัััั ะฝะฐ ะฑะฐะปั
rus_verbs:ัะตััะธัั{}, // ัะตััะธัั ะฝะฐ ะดะพัะบะต
rus_verbs:ะพััะฐะทะธัััั{}, // ะพััะฐะทะธัััั ะฝะฐ ะพัะตะฝะบะฐั
rus_verbs:ะณัะตัั{}, // ะณัะตัั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ัะฐัััะถะดะฐัั{}, // ัะฐัััะถะดะฐัั ะฝะฐ ัััะฐะฝะธัะฐั
ัะฒะพะตะน ะบะฝะธะณะธ
rus_verbs:ะพะบััะถะฐัั{}, // ะพะบััะถะฐัั ะฝะฐ ะพัััะพะฒะต
rus_verbs:ัะพะฟัะพะฒะพะถะดะฐัั{}, // ัะพะฟัะพะฒะพะถะดะฐัั ะฝะฐ ะพั
ะพัะต
rus_verbs:ะทะฐะบะฐะฝัะธะฒะฐัััั{}, // ะทะฐะบะฐะฝัะธะฒะฐัััั ะฝะฐ ัะฐะผะพะผ ะธะฝัะตัะตัะฝะพะผ ะผะตััะต
rus_verbs:ัะพะดะตัะถะฐัััั{}, // ัะพะดะตัะถะฐัััั ะฝะฐ ะฟัะธััะฐะดะตะฑะฝะพะผ ััะฐััะบะต
rus_verbs:ะฟะพัะตะปะธัััั{}, // ะฟะพัะตะปะธัััั ะฝะฐ ะดะฐัะต
rus_verbs:ะทะฐะฟะตัั{}, // ะทะฐะฟะตัั ะฝะฐ ััะตะฝะต
ะธะฝัะธะฝะธัะธะฒ:ะฟัะพะฒะพะทะธัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฟัะพะฒะพะทะธัั ะฝะฐ ัะตะปะต
ะณะปะฐะณะพะป:ะฟัะพะฒะพะทะธัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟัะพะฒะตะทะตะฝะฝัะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟัะพะฒะพะทะธะฒัะธะน{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟัะพะฒะพะทััะธะน{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ะฟัะพะฒะพะทั{},
rus_verbs:ะผะพัะธัั{}, // ะผะพัะธัั ะฝะฐ ะผะตััะต
rus_verbs:ะฟัะตัะปะตะดะพะฒะฐัั{}, // ะฟัะตัะปะตะดะพะฒะฐัั ะฝะฐ ัะตััะธัะพัะธะธ ะดััะณะพะณะพ ััะฐัะฐ
rus_verbs:ะฟัะพะปะตัะตัั{}, // ะฟัะพะปะตัะตะป ะฝะฐ ะฟะฐัะฐะฟะปะฐะฝะต
rus_verbs:ะดัะฐัััั{}, // ะดัะฐัััั ะฝะฐ ัะฐะฟะธัะฐั
rus_verbs:ะฟัะพัะธะดะตัั{}, // ะฟัะพัะธะดะตัั ะฝะฐ ะทะฐะฝััะธัั
rus_verbs:ัะฑะธัะฐัััั{}, // ัะฑะธัะฐัััั ะฝะฐ ะฑะฐะปะบะพะฝะต
rus_verbs:ัะฐััั{}, // ัะฐััั ะฝะฐ ัะพะปะฝัะต
rus_verbs:ะฟัะพะฒะตัััั{}, // ะฟัะพะฒะตัััั ะฝะฐ ะฟะพะปะธะณัะฐัะต
rus_verbs:ัะฑะตะถะดะฐัั{}, // ัะฑะตะถะดะฐัั ะฝะฐ ะฟัะธะผะตัะต
rus_verbs:ัะบะพะปัะทะธัั{}, // ัะบะพะปัะทะธัั ะฝะฐ ะปัะดั
rus_verbs:ะฟัะธะพะฑัะตัะฐัั{}, // ะฟัะธะพะฑัะตัะฐัั ะฝะฐ ัะฐัะฟัะพะดะฐะถะต
rus_verbs:ะปะตัะฐัั{}, // ะปะตัะฐัั ะฝะฐ ะผะตัะปะต
rus_verbs:ัะพะปะฟะธัััั{}, // ัะพะปะฟะธัััั ะฝะฐ ะฟะตััะพะฝะต
rus_verbs:ะฟะปะฐะฒะฐัั{}, // ะฟะปะฐะฒะฐัั ะฝะฐ ะฝะฐะดัะฒะฝะพะผ ะผะฐััะฐัะต
rus_verbs:ะพะฟะธััะฒะฐัั{}, // ะพะฟะธััะฒะฐัั ะฝะฐ ัััะฐะฝะธัะฐั
ะฟะพะฒะตััะธ
rus_verbs:ะฟัะพะฑััั{}, // ะฟัะพะฑััั ะฝะฐ ัะพะปะฝัะต ัะปะธัะบะพะผ ะดะพะปะณะพ
rus_verbs:ะทะฐัััััั{}, // ะทะฐัััััั ะฝะฐ ะฒะตัั
ะฝะตะผ ััะฐะถะต
rus_verbs:ะผะตัะฐัััั{}, // ะผะตัะฐัััั ะฝะฐ ะฟะพะปั
rus_verbs:ัะถะตัั{}, // ัะถะตัั ะฝะฐ ะบะพัััะต
rus_verbs:ัะฐััะปะฐะฑะธัััั{}, // ัะฐััะปะฐะฑะธัััั ะฝะฐ ะบััะตัะบะต
rus_verbs:ััะปัั
ะฐัั{}, // ััะปัั
ะฐัั ะฝะฐ ััะฝะบะต
rus_verbs:ัะดะตัะถะฐัั{}, // ัะดะตัะถะฐัั ะฝะฐ ะฟัะตะถะฝะตะผ ััะพะฒะฝะต
rus_verbs:ะพะฑัะฐะทะพะฒะฐัััั{}, // ะพะฑัะฐะทะพะฒะฐัััั ะฝะฐ ะดะฝะต
rus_verbs:ัะฐััะผะพััะตัั{}, // ัะฐััะผะพััะตัั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััะธ ัะธะฟะฐ
rus_verbs:ัะตะทะถะฐัั{}, // ัะตะทะถะฐัั ะฝะฐ ะฟะพะฟััะบะต
rus_verbs:ะฟะพั
ะพัะพะฝะธัั{}, // ะฟะพั
ะพัะพะฝะธัั ะฝะฐ ะทะฐะบัััะพะผ ะบะปะฐะดะฑะธัะต
rus_verbs:ะฝะฐััะพััั{}, // ะฝะฐััะพััั ะฝะฐ ะฟะตัะตัะผะพััะต ะพัะตะฝะพะบ
rus_verbs:ัะฐัััะฝััััั{}, // ัะฐัััะฝััััั ะฝะฐ ะณะพัััะตะผ ะฟะตัะบะต
rus_verbs:ะฟะพะบัััะธัั{}, // ะฟะพะบัััะธัั ะฝะฐ ัะตััะต
rus_verbs:ะพะฑะฝะฐััะถะธัััั{}, // ะพะฑะฝะฐััะถะธัััั ะฝะฐ ะฑะพะปะพัะต
rus_verbs:ะณัะปััั{}, // ะณัะปััั ะฝะฐ ัะฒะฐะดัะฑะต
rus_verbs:ััะพะฝััั{}, // ััะพะฝััั ะฝะฐ ะบััะพััะต
rus_verbs:ั
ัะฐะฝะธัััั{}, // ั
ัะฐะฝะธัััั ะฝะฐ ะดะตะฟะพะทะธัะต
rus_verbs:ัะฐะฝัะตะฒะฐัั{}, // ัะฐะฝัะตะฒะฐัั ะฝะฐ ัะฒะฐะดัะฑะต
rus_verbs:ัััะดะธัััั{}, // ัััะดะธัััั ะฝะฐ ะทะฐะฒะพะดะต
ะธะฝัะธะฝะธัะธะฒ:ะทะฐััะฟะฐัั{ะฟะตัะตั
ะพะดะฝะพััั:ะฝะตะฟะตัะตั
ะพะดะฝัะน ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะทะฐััะฟะฐัั ะฝะฐ ะบัะพะฒะฐัะธ
ะณะปะฐะณะพะป:ะทะฐััะฟะฐัั{ะฟะตัะตั
ะพะดะฝะพััั:ะฝะตะฟะตัะตั
ะพะดะฝัะน ะฒะธะด:ะฝะตัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ะทะฐััะฟะฐั{ะฟะตัะตั
ะพะดะฝะพััั:ะฝะตะฟะตัะตั
ะพะดะฝัะน ะฒะธะด:ะฝะตัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะทะฐััะฟะฐะฒัะธะน{ะฟะตัะตั
ะพะดะฝะพััั:ะฝะตะฟะตัะตั
ะพะดะฝัะน ะฒะธะด:ะฝะตัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะทะฐััะฟะฐััะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั ะฟะตัะตั
ะพะดะฝะพััั:ะฝะตะฟะตัะตั
ะพะดะฝัะน }, // ัะตะฑะตะฝะพะบ, ะทะฐััะฟะฐััะธะน ะฝะฐ ััะบะฐั
rus_verbs:ัััะธัั{}, // ัััะธัั ะฝะฐ ะพัะบัััะพะผ ะฒะพะทะดัั
ะต
rus_verbs:ะทะฐัะตะฒะตะปะธัััั{}, // ะทะฐัะตะฒะตะปะธัััั ะฝะฐ ัะตัะดะฐะบะต
rus_verbs:ะพะฑะดัะผัะฒะฐัั{}, // ะพะฑะดัะผัะฒะฐัั ะฝะฐ ะดะพััะณะต
rus_verbs:ะดะพะบะปะฐะดัะฒะฐัั{}, // ะดะพะบะปะฐะดัะฒะฐัั ะฝะฐ ะฝะฐััะฝะพะน ะบะพะฝัะตัะตะฝัะธะธ
rus_verbs:ะฟัะพะผะตะปัะบะฝััั{}, // ะฟัะพะผะตะปัะบะฝััั ะฝะฐ ัะบัะฐะฝะต
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐั
ะพะดััะธะนัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะบะพะปะพะฝะฝะฐ, ะฝะฐั
ะพะดััะฐััั ะฝะฐ ะฝะธัะตะนะฝะพะน ัะตััะธัะพัะธะธ
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐะฟะธัะฐะฝะฝัะน{}, // ัะปะพะฒะพ, ะฝะฐะฟะธัะฐะฝะฝะพะต ะฝะฐ ะทะฐะฑะพัะต
rus_verbs:ัะผะตัะฐัััั{}, // ะบะพะผะฟัััะตั, ัะผะตัะฐััะธะนัั ะฝะฐ ะปะฐะดะพะฝะธ
rus_verbs:ะพัะบัััั{}, // ะบะฝะธะณะฐ, ะพัะบัััะฐั ะฝะฐ ะฟะพัะปะตะดะฝะตะน ัััะฐะฝะธัะต
rus_verbs:ัะฟะฐัั{}, // ะนะพะณ, ัะฟััะธะน ะฝะฐ ะณะฒะพะทะดัั
rus_verbs:ะฟัะพะฑัะบัะพะฒัะฒะฐัั{}, // ะบะพะปะตัะพ, ะฟัะพะฑัะบัะพะฒัะฒะฐััะตะต ะฝะฐ ะพะฑะปะตะดะตะฝะตะปะพะผ ะฐััะฐะปััะต
rus_verbs:ะทะฐะฑัะบัะพะฒะฐัั{}, // ะบะพะปะตัะพ, ะทะฐะฑัะบัะพะฒะฐะฒัะตะต ะฝะฐ ะพะฑะปะตะดะตะฝะตะปะพะผ ะฐััะฐะปััะต
rus_verbs:ะพัะพะฑัะฐะทะธัััั{}, // ัะดะธะฒะปะตะฝะธะต, ะพัะพะฑัะฐะทะธะฒัะตะตัั ะฝะฐ ะปะธัะต
rus_verbs:ัะฒะธะดะตัั{}, // ะฝะฐ ะฟะพะปั ั ัะฒะธะดะตะป ััะธ-ัะพ ัะปะตะดั
rus_verbs:ะฒะธะดะตัั{}, // ะฝะฐ ะฟะพะปั ั ะฒะธะถั ััะธ-ัะพ ัะปะตะดั
rus_verbs:ะพััะฐะฒะธัั{}, // ะะตะป ะพััะฐะฒะธะป ะฝะฐ ะดะพัะบะต ะฑะตะปัะน ัะปะตะด.
rus_verbs:ะพััะฐะฒะปััั{}, // ะะตะป ะพััะฐะฒะปัะตั ะฝะฐ ะดะพัะบะต ะฑะตะปัะน ัะปะตะด.
rus_verbs:ะฒัััะตัะฐัััั{}, // ะฒัััะตัะฐัััั ะฝะฐ ะปะตะบัะธัั
rus_verbs:ะฟะพะทะฝะฐะบะพะผะธัััั{}, // ะฟะพะทะฝะฐะบะพะผะธัััั ะฝะฐ ะทะฐะฝััะธัั
rus_verbs:ััััะพะธัััั{}, // ะพะฝะฐ ััััะพะธะปะฐัั ะฝะฐ ะบัะพะฒะฐัะธ
rus_verbs:ะปะพะถะธัััั{}, // ะปะพะถะธัั ะฝะฐ ะฟะพะปั
rus_verbs:ะพััะฐะฝะฐะฒะปะธะฒะฐัััั{}, // ะพััะฐะฝะฐะฒะปะธะฒะฐัััั ะฝะฐ ะดะพััะธะณะฝััะพะผ
rus_verbs:ัะฟะพััะบะฐัััั{}, // ัะฟะพััะบะฐัััั ะฝะฐ ัะพะฒะฝะพะผ ะผะตััะต
rus_verbs:ัะฐัะฟะตัะฐัะฐัั{}, // ัะฐัะฟะตัะฐัะฐัั ะฝะฐ ะฑัะผะฐะณะต
rus_verbs:ัะฐัะฟะตัะฐััะฒะฐัั{}, // ัะฐัะฟะตัะฐััะฒะฐัั ะฝะฐ ะฑัะผะฐะณะต
rus_verbs:ะฟัะพัะผะพััะตัั{}, // ะฟัะพัะผะพััะตัั ะฝะฐ ะฑัะผะฐะณะต
rus_verbs:ะทะฐะบัะตะฟะปััััั{}, // ะทะฐะบัะตะฟะปััััั ะฝะฐ ะฟะปะฐัะดะฐัะผะต
rus_verbs:ะฟะพะณัะตัััั{}, // ะฟะพะณัะตัััั ะฝะฐ ัะพะปะฝััะบะต
rus_verbs:ะผะตัะฐัั{}, // ะะฝ ะผะตัะฐะป ะบัะฐัะบะธ ะฝะฐ ะฟะฐะปะธััะต.
rus_verbs:ะทะฐะฝััั{}, // ะะฝ ะทะฐะฝัะป ะฟะตัะฒะพะต ะผะตััะพ ะฝะฐ ัะพัะตะฒะฝะพะฒะฐะฝะธัั
.
rus_verbs:ะทะฐะณะพะฒะฐัะธะฒะฐัััั{}, // ะะฝ ะทะฐะณะพะฒะฐัะธะฒะฐะปัั ะธะฝะพะณะดะฐ ะฝะฐ ััะพะบะฐั
.
ะดะตะตะฟัะธัะฐััะธะต:ะถะตะฝะธะฒัะธัั{ ะฒะธะด:ัะพะฒะตัั },
rus_verbs:ะฒะตะทัะธ{}, // ะะฝ ะฒะตะทัั ะฟะตัะพะบ ะฝะฐ ัะฐัะบะต.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะบะฐะทะฝะตะฝะฝัะน{}, // ะะฝ ะฑัะป ะบะฐะทะฝัะฝ ะฝะฐ ัะปะตะบััะธัะตัะบะพะผ ัััะปะต.
rus_verbs:ะฟัะพะถะธัั{}, // ะะฝ ะฑะตะทะฒัะตะทะดะฝะพ ะฟัะพะถะธะป ะฒัั ะปะตัะพ ะฝะฐ ะดะฐัะต.
rus_verbs:ะฟัะธะฝะตััะธ{}, // ะัะธัะธะฐะฝัะบะฐ ะฟัะธะฝะตัะปะฐ ะฝะฐะผ ะพะฑะตะด ะฝะฐ ะฟะพะดะฝะพัะต.
rus_verbs:ะฟะตัะตะฟะธัะฐัั{}, // ะะตัะตะฟะธัะธัะต ััั ััะบะพะฟะธัั ะฝะฐ ะผะฐัะธะฝะบะต.
rus_verbs:ะธะดัะธ{}, // ะะพะตะทะด ะธะดัั ะฝะฐ ะผะฐะปะพะน ัะบะพัะพััะธ.
rus_verbs:ะฟะตัั{}, // ะฟัะธัะบะธ ะฟะพัั ะฝะฐ ัะฐััะฒะตัะต
rus_verbs:ัะผะพััะตัั{}, // ะกะผะพััะธ ะฝะฐ ะพะฑะพัะพัะต.
rus_verbs:ะฟัะธะฑัะฐัั{}, // ะฟัะธะฑัะฐัั ะฝะฐ ััะพะปะต
rus_verbs:ะฟัะธะฑัะฐัััั{}, // ะฟัะธะฑัะฐัััั ะฝะฐ ััะพะปะต
rus_verbs:ัะฐััะธัั{}, // ัะฐััะธัั ะบะฐะฟัััั ะฝะฐ ะพะณะพัะพะดะต
rus_verbs:ัะฐัะธัั{}, // ัะฐัะธัั ัะตะฑะตะฝะบะฐ ะฝะฐ ััะบะฐั
rus_verbs:ัะฑะธัะฐัั{}, // ัะฑะธัะฐัั ะฝะฐ ััะพะปะต
rus_verbs:ะฟัะพััััั{}, // ะฏ ะฟัะพัััะป ะฝะฐ ะผะพัะพะทะต.
rus_verbs:ัะธััั{}, // ััะฝัะต ะทะฒะตะทะดั ะผะธัะฝะพ ัะธัะปะธ ะฝะฐ ะฑะตะทะพะฑะปะฐัะฝะพะผ ะฒะตัะตะฝะฝะตะผ ะฝะตะฑะต.
rus_verbs:ะฟัะพะฒะพะดะธัััั{}, // ัะฐะบะธะต ัะบัะฟะตัะธะผะตะฝัั ะฝะต ะฟัะพะฒะพะดัััั ะฝะฐ ะฒะพะดะต
rus_verbs:ะดะพััะฐัั{}, // ะฏ ะฝะต ะผะพะณั ะดะพััะฐัั ะดะพ ัะฑะปะพะบ ะฝะฐ ะฒะตัั
ะฝะธั
ะฒะตัะบะฐั
.
rus_verbs:ัะฐัะฟะปััััั{}, // ะงะตัะฝะธะปะฐ ัะฐัะฟะปัะปะธัั ะฝะฐ ะฟะปะพั
ะพะน ะฑัะผะฐะณะต.
rus_verbs:ะฒัะบะพัะธัั{}, // ะฃ ะฝะตะณะพ ะฒัะบะพัะธะป ะฟััั ะฝะฐ ะฝะพัั.
rus_verbs:ัะฒะธัั{}, // ะฃ ะฝะฐั ะฝะฐ ะฑะฐะปะบะพะฝะต ะฒะพัะพะฑะตะน ัะฒะธะป ะณะฝะตะทะดะพ.
rus_verbs:ะพัะพัะฒะฐัััั{}, // ะฃ ะผะตะฝั ะฝะฐ ะฟะฐะปััะพ ะพัะพัะฒะฐะปะฐัั ะฟัะณะพะฒะธัะฐ.
rus_verbs:ะฒะพัั
ะพะดะธัั{}, // ะกะพะปะฝัะต ะฒะพัั
ะพะดะธั ะฝะฐ ะฒะพััะพะบะต.
rus_verbs:ะฑะปะตััะตัั{}, // ะกะฝะตะณ ะฑะปะตััะธั ะฝะฐ ัะพะปะฝัะต.
rus_verbs:ะฟะพะฑะธัั{}, // ะ ััะฐะบ ะฟะพะฑะธะป ะฒัะตั
ะปะพัะฐะดะตะน ะฝะฐ ัะบะฐัะบะฐั
.
rus_verbs:ะปะธัััั{}, // ะ ะตะบะธ ะบัะพะฒะธ ะปััััั ะฝะฐ ะฒะพะนะฝะต.
rus_verbs:ะดะตัะถะฐัััั{}, // ะ ะตะฑัะฝะพะบ ัะถะต ัะฒััะดะพ ะดะตัะถะธััั ะฝะฐ ะฝะพะณะฐั
.
rus_verbs:ะบะปัะฑะธัััั{}, // ะัะปั ะบะปัะฑะธััั ะฝะฐ ะดะพัะพะณะต.
ะธะฝัะธะฝะธัะธะฒ:ะฝะฐะฟะธัะฐัั{ aux stress="ะฝะฐะฟะธั^ะฐัั" }, // ะขั ะดะพะปะถะตะฝ ะฝะฐะฟะธัะฐัั ััะฐััั ะฝะฐ ะฐะฝะณะปะธะนัะบะพะผ ัะทัะบะต
ะณะปะฐะณะพะป:ะฝะฐะฟะธัะฐัั{ aux stress="ะฝะฐะฟะธั^ะฐัั" }, // ะะฝ ะฝะฐะฟะธัะฐะป ััะฐััั ะฝะฐ ััััะบะพะผ ัะทัะบะต.
// ะณะปะฐะณะพะป:ะฝะฐั
ะพะดะธัััั{ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะผะพะน ะฟะพะตะทะด ะฝะฐั
ะพะดะธััั ะฝะฐ ะฟะตัะฒะพะผ ะฟััะธ
// ะธะฝัะธะฝะธัะธะฒ:ะฝะฐั
ะพะดะธัััั{ะฒะธะด:ะฝะตัะพะฒะตัั},
rus_verbs:ะถะธัั{}, // ะัะปะพ ะธะฝัะตัะตัะฝะพ ะถะธัั ะฝะฐ ะบััะพััะต.
rus_verbs:ะฟะพะฒะธะดะฐัั{}, // ะะฝ ะผะฝะพะณะพ ะฟะพะฒะธะดะฐะป ะฝะฐ ัะฒะพัะผ ะฒะตะบั.
rus_verbs:ัะฐะทัะตะทะถะฐัััั{}, // ะะพะณะธ ัะฐะทัะตะทะถะฐัััั ะฝะต ัะพะปัะบะพ ะฝะฐ ะปัะดั.
rus_verbs:ัะฐัะฟะพะปะพะถะธัััั{}, // ะะฑะฐ ัะตะปะฐ ัะฐัะฟะพะปะพะถะธะปะธัั ะฝะฐ ะฑะตัะตะณั ัะตะบะธ.
rus_verbs:ะพะฑัััะฝััััั{}, // ะะฝะธ ะพะฑัััะฝััััั ะฝะฐ ะธะฝะพัััะฐะฝะฝะพะผ ัะทัะบะต.
rus_verbs:ะฟัะพัะฐัััั{}, // ะะฝะธ ะดะพะปะณะพ ะฟัะพัะฐะปะธัั ะฝะฐ ะฒะพะบะทะฐะปะต.
rus_verbs:ัะฐะฑะพัะฐัั{}, // ะะฝะฐ ัะฐะฑะพัะฐะตั ะฝะฐ ัะบะฐัะบะพะน ัะฐะฑัะธะบะต.
rus_verbs:ะบัะฟะธัั{}, // ะะฝะฐ ะบัะฟะธะปะฐ ะผะพะปะพะบะพ ะฝะฐ ััะฝะบะต.
rus_verbs:ะฟะพะผะตััะธัััั{}, // ะัะต ะบะฝะธะณะธ ะฟะพะผะตััะธะปะธัั ะฝะฐ ะฟะพะปะบะต.
ะณะปะฐะณะพะป:ะฟัะพะฒะพะดะธัั{ะฒะธะด:ะฝะตัะพะฒะตัั}, ะธะฝัะธะฝะธัะธะฒ:ะฟัะพะฒะพะดะธัั{ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะัะถะฝะพ ะฟัะพะฒะพะดะธัั ัะตะพัะธั ะฝะฐ ะฟัะฐะบัะธะบะต.
rus_verbs:ะฟะพะถะธัั{}, // ะะตะดะพะปะณะพ ะพะฝะฐ ะฟะพะถะธะปะฐ ะฝะฐ ัะฒะตัะต.
rus_verbs:ะบัะฐัะฝะตัั{}, // ะะตะฑะพ ะบัะฐัะฝะตะตั ะฝะฐ ะทะฐะบะฐัะต.
rus_verbs:ะฑัะฒะฐัั{}, // ะะฐ ะะพะปะณะต ะฑัะฒะฐะตั ัะธะปัะฝะพะต ะฒะพะปะฝะตะฝะธะต.
rus_verbs:ะตั
ะฐัั{}, // ะั ััะดะฐ ะตั
ะฐะปะธ ะฝะฐ ะฐะฒัะพะฑััะต.
rus_verbs:ะฟัะพะฒะตััะธ{}, // ะั ะฟัะพะฒะตะปะธ ะผะตััั ะฝะฐ ะดะฐัะต.
rus_verbs:ะฟะพะทะดะพัะพะฒะฐัััั{}, // ะั ะฟะพะทะดะพัะพะฒะฐะปะธัั ะฟัะธ ะฒัััะตัะต ะฝะฐ ัะปะธัะต.
rus_verbs:ัะฐััะธ{}, // ะัะฑัะทั ัะฐัััั ัะตะฟะตัั ะฝะต ัะพะปัะบะพ ะฝะฐ ัะณะต.
ะะ_ะะะค(ัะธะดะตัั), // ััะธ ะฑะพะปััะธั
ะฟัะฐ ัะธะดัั ะฝะฐ ััะฐะฒะต
ะะ_ะะะค(ัะตััั), // ััะธ ะฑะพะปััะธั
ะฟัะฐ ัะตะปะธ ะฝะฐ ััะฐะฒั
ะะ_ะะะค(ะฟะตัะตะฒะตัะฝััััั), // ะะฐ ะดะพัะพะณะต ะฟะตัะตะฒะตัะฝัะปัั ะฐะฒัะพะผะพะฑะธะปั
ะะ_ะะะค(ะฟะพะฒะตะทัะธ), // ั ะฟะพะฒะตะทั ัะตะฑั ะฝะฐ ะผะฐัะธะฝะต
ะะ_ะะะค(ะพัะฒะตะทัะธ), // ะผั ะพัะฒะตะทะตะผ ัะตะฑั ะฝะฐ ัะฐะบัะธ
ะะ_ะะะค(ะฟะธัั), // ะฟะธัั ะฝะฐ ะบัั
ะฝะต ัะฐะน
ะะ_ะะะค(ะฝะฐะนัะธ), // ะฝะฐะนัะธ ะฝะฐ ะพัััะพะฒะต
ะะ_ะะะค(ะฑััั), // ะฝะฐ ััะธั
ะบะพัััั
ะตััั ัะปะตะดั ะทัะฑะพะฒ
ะะ_ะะะค(ะฒััะฐะดะธัััั), // ะฟะพะผะพัะฝะธะบะธ ะฒััะฐะดะธะปะธัั ะฝะฐ ะพัััะพะฒะต
ะะ_ะะะค(ะดะตะปะฐัั),ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะดะตะปะฐััะธะน{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะดะตะปะฐะฒัะธะน{}, ะดะตะตะฟัะธัะฐััะธะต:ะดะตะปะฐั{}, // ัะผะพััั ัะธะปัะผ ะพ ัะพะผ, ััะพ ะฟะธัะฐัั ะดะตะปะฐะปะธ ะฝะฐ ะฝะตะพะฑะธัะฐะตะผะพะผ ะพัััะพะฒะต
ะะ_ะะะค(ัะปััะธัััั), // ััะพ ัะปััะธะปะพัั ะฝะฐ ะพะฟััะบะต ะปะตัะฐ
ะะ_ะะะค(ะฟัะพะดะฐัั),
ะะ_ะะะค(ะตััั) // ะบะพัะบะธ ะตะปะธ ะผะพะน ะบะพัะผ ะฝะฐ ะฟะตััะฐะฝะพะผ ะฑะตัะตะณั
}
#endregion VerbList
// ะงัะพะฑั ัะฐะทัะตัะธัั ัะฒัะทัะฒะฐะฝะธะต ะฒ ะฟะฐััะตัะฝะฐั
ัะธะฟะฐ: ัะผะพััะตัั ะฝะฐ youtube
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะ_ะัะตะดะป ะฟัะตะดะปะพะณ:ะฒ{} @regex("[a-z]+[0-9]*") }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะ_ะัะตะดะป ะฟัะตะดะปะพะณ:ะฝะฐ{} *:*{ะฟะฐะดะตะถ:ะฟัะตะดะป} }
then return true
}
// ะปะพะบะฐัะธะฒ
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะ_ะัะตะดะป ะฟัะตะดะปะพะณ:ะฝะฐ{} *:*{ะฟะฐะดะตะถ:ะผะตัั} }
then return true
}
#endregion ะะ ะะะะะะะซะ
#region ะะะะะขะะะฌะะซะ
// ะะ+ะฒะธะฝะธัะตะปัะฝัะน ะฟะฐะดะตะถ:
// ะะะะะ ะะขะฌะกะฏ ะะ ะะะ ะจะะะฃ ะะะ ะซ
#region VerbList
wordentry_set ะะป_ะะ_ะะธะฝ=
{
rus_verbs:ะฟะตัะตะผะตัะฝััััั{}, // ะะต ะฒะทะณะปัะด ัะฐััะตััะฝะฝะพ ะฟะตัะตะผะตัะฝัะปัั ะฝะฐ ะะธะปะธ.
rus_verbs:ะพัะพะณะฝะฐัั{}, // ะะพะดะธัะตะปั ะพัะพะณะฝะฐะป ะผะฐัะธะฝั ะฝะฐ ััะพัะฝะบั.
rus_verbs:ัะฐะฟะฐัั{}, // ะะต ัะฐะฟะฐะน ะฝะฐ ะถะตะปััะบ ะธ ะฝะต ะฟะตัะตะฑะธะฒะฐะน.
rus_verbs:ัะผะฝะพะถะธัั{}, // ะฃะผะฝะพะถััะต ััะพ ะบะพะปะธัะตััะฒะพ ะฟัะธะผะตัะฝะพ ะฝะฐ 10.
//rus_verbs:ัะผะฝะพะถะฐัั{},
rus_verbs:ะพัะบะฐัะธัั{}, // ะัะบะฐัะธะป ะจะฟะฐะบ ะฒะฐะปัะฝ ะฝะฐ ัะปัั
ะธ ะฟะตัะตะบััะป ะธะผ ะดะพัะพะณั.
rus_verbs:ะพัะบะฐััะฒะฐัั{},
rus_verbs:ะดะพะฝะพัะธัั{}, // ะะพั ะธ ะฟะพะฑะตะถะฐะปะธ ะฝะฐ ะฒะฐั ะดะพะฝะพัะธัั.
rus_verbs:ะดะพะฝะตััะธ{},
rus_verbs:ัะฐะทะฑะธัะฐัั{}, // ะะพัะพะฒะฐะฝะฝัะต ะฐะฒัะพะผะพะฑะธะปะธ ะทะปะพัะผััะปะตะฝะฝะธะบะธ ัะฐะทะฑะธัะฐะปะธ ะฝะฐ ะทะฐะฟัะฐััะธ ะธ ะฟัะพะดะฐะฒะฐะปะธ.
ะฑะตะทะปะธั_ะณะปะฐะณะพะป:ั
ะฒะฐัะธั{}, // - ะะฐ ะพะดะฝั ะฐัะฐะบั ั
ะฒะฐัะธั.
rus_verbs:ัะบัะฟะธัััั{}, // ะะฝ ััะฐะถะฐะปัั ะทะฐ ะถะธะทะฝั, ะฝะต ัะบัะฟััั ะฝะฐ ั
ะธััะพััะธ ะธ ััะธะปะธั, ะธ ะฟะพะบะฐ ััะพั ััะธะปั ะดะฐะฒะฐะป ะฝะตะฟะปะพั
ะธะต ัะตะทัะปััะฐัั.
rus_verbs:ะฟะพัะบัะฟะธัััั{}, // ะะต ะฟะพัะบัะฟะธัั ะฝะฐ ะฟะพั
ะฒะฐะปั!
rus_verbs:ะฟะพะดัะผะฐัััั{},
rus_verbs:ััะฐะฝัะฟะพััะธัะพะฒะฐัััั{},
rus_verbs:ะฑะฐั
ะฝััั{}, // ะะฐั
ะฝััั ััะฐะบะฐะฝ ะฝะฐ ะฟะพะป
rus_verbs:ะ ะะะะะะะขะฌ{}, // ะัะตะทะธะดะตะฝััะบะธะต ะฒัะฑะพัั ัะฐะทะดะตะปะธะปะธ ะะตะฝะตัััะปั ะฝะฐ ะดะฒะฐ ะฝะตะฟัะธะผะธัะธะผัั
ะปะฐะณะตัั (ะ ะะะะะะะขะฌ)
rus_verbs:ะะะฆะะะะะะขะฌะกะฏ{}, // ะะตะฒะดะฐะปะตะบะต ะฟัะพะปะตัะตะป ะบะพะฝะดะพั, ะฝะฐัะตะปะธะฒะฐััั ะฝะฐ ะฑะธะทะพะฝัั ัััั. (ะะะฆะะะะะะขะฌะกะฏ)
rus_verbs:ะะซะะะะกะะฃะขะฌ{}, // ะะธะทะบะธะน ะฒะธะฑัะธััััะธะน ะณัะป ะฝะฐะฟะพะผะธะฝะฐะป ะฒัะปะบะฐะฝ, ะฒะพั-ะฒะพั ะณะพัะพะฒัะน ะฒัะฟะปะตัะฝััั ะฝะฐ ะทะตะผะฝัั ัะฒะตัะดั ะฟะพัะพะบะธ ัะฐัะบะฐะปะตะฝะฝะพะน ะปะฐะฒั. (ะะซะะะะกะะฃะขะฌ)
rus_verbs:ะะกะงะะะะฃะขะฌ{}, // ะะฝะพ ัััะบะฝัะปะพ ะธ ะธััะตะทะปะพ ะฒ ะปะตัั ะฝะฐ ะดััะณะพะน ััะพัะพะฝะต ะดะพัะพะณะธ (ะะกะงะะะะฃะขะฌ)
rus_verbs:ะะซะะะะขะฌ{}, // ะฒัะทะฒะฐัั ัะฒะพะตะณะพ ะฑัะฐัะฐ ะฝะฐ ะฟะพะตะดะธะฝะพะบ. (ะะซะะะะขะฌ)
rus_verbs:ะะะะ ะซะะะะขะฌ{}, // ะะฐััะพั ะฟะพะฑััะทะณะฐะป ะฝะตะผะฝะพะณะพ ัะธะผะธะฐะผะฐ ะฝะฐ ะบัะพัะตัะฝัะน ะพะณะพะฝั (ะะะะ ะซะะะะขะฌ/ะะ ะซะะะะขะฌ/ะะ ะซะะะฃะขะฌ/ะะะะะฃะขะฌ/ะะะะะขะฌ/ะะะะะะะขะฌ)
rus_verbs:ะะ ะซะะะะขะฌ{},
rus_verbs:ะะ ะซะะะฃะขะฌ{},
rus_verbs:ะะะะะฃะขะฌ{},
rus_verbs:ะะะะะขะฌ{},
rus_verbs:ะะะะะะะขะฌ{},
rus_verbs:ะะะะฅะะขะะขะฌะกะฏ{}, // ะั ะผะพะถะตะผ ะบะพะณะดะฐ-ะฝะธะฑัะดั ะฒะตัะฝััััั ะธ ะฟะพะพั
ะพัะธัััั ะฝะฐ ะฝะตะณะพ. (ะะะะฅะะขะะขะฌะกะฏ/ะะฅะะขะะขะฌะกะฏ)
rus_verbs:ะะฅะะขะะขะฌะกะฏ{}, //
rus_verbs:ะะะะะกะขะฌะกะฏ{}, // ะะต ะดัะผะฐะป ั, ััะพ ะพะฝะธ ะฟะพะฟะฐะดัััั ะฝะฐ ััะพ (ะะะะะกะขะฌะกะฏ/ะะะ ะะะขะฌะกะฏ/ะะะขะะะะะฃะขะฌะกะฏ)
rus_verbs:ะะะ ะะะขะฌะกะฏ{}, //
rus_verbs:ะะะขะะะะะฃะขะฌะกะฏ{}, //
rus_verbs:ะะซะกะะะขะฌ{}, // ะะฝ ะฒััะปะฐะป ัะฐะทะฒะตะดัะธะบะพะฒ ะฝะฐ ะฑะพะปััะพะต ัะฐัััะพัะฝะธะต ะพั ะพัะฝะพะฒะฝะพะณะพ ะพัััะดะฐ. (ะะซะกะะะขะฌ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะะฅะะะะ{}, // ะขั ะฝะต ะฒัะณะปัะดะธัั ะฟะพั
ะพะถะธะผ ะฝะฐ ะธะฝะดะตะนัะฐ (ะะะฅะะะะ)
rus_verbs:ะ ะะะะ ะะะขะฌ{}, // ะงะตัะตะท ะผะธะฝััั ะพะฝ ะฑัะป ะผะตััะฒ ะธ ัะฐะทะพัะฒะฐะฝ ะฝะฐ ัะฐััะธ. (ะ ะะะะ ะะะขะฌ)
rus_verbs:ะกะขะะะะะฃะขะฌ{}, // ะขะพะปัะบะพ ะฑัััััะผะธ ะฒัะฟะฐะดะฐะผะธ ะบะพะฟัั ะพะฝ ััะผะตะป ััะพะปะบะฝััั ะธั
ะพะฑัะฐัะฝะพ ะฝะฐ ะบะฐัะฝะธะท. (ะกะขะะะะะฃะขะฌ/ะกะขะะะะะะะขะฌ)
rus_verbs:ะกะขะะะะะะะขะฌ{}, //
rus_verbs:ะกะะฃะกะขะะขะฌ{}, // ะฏ ะฟะพะฑะตะถะฐะป ะบ ะฝะธะผ, ะฝะพ ะพะฝะธ ะบ ัะพะผั ะฒัะตะผะตะฝะธ ัะฟัััะธะปะธ ะปะพะดะบั ะฝะฐ ะฒะพะดั (ะกะะฃะกะขะะขะฌ)
rus_verbs:ะะะ ะะะ ะะกะซะะะขะฌ{}, // ะกะธัะธั ะฟะตัะตะฑัะฐััะฒะฐะตั ะฝะฐ ัะณ ัััะฐะฝั ะฒะพะธะฝัะบะธะต ะฟะพะดะบัะตะฟะปะตะฝะธั (ะะะ ะะะ ะะกะซะะะขะฌ, ะะะ ะะะ ะะกะะขะฌ, ะะะะ ะะกะซะะะขะฌ, ะะะะ ะะกะะขะฌ)
rus_verbs:ะะะ ะะะ ะะกะะขะฌ{}, //
rus_verbs:ะะะะ ะะกะซะะะขะฌ{}, //
rus_verbs:ะะะะ ะะกะะขะฌ{}, //
rus_verbs:ะกะะะ ะะฃะขะฌ{}, // ะะฝ ะฒัะฒะตะป ะผะฐัะธะฝั ะฝะฐ ะฑัะปัะฒะฐั ะธ ะฟะพะตั
ะฐะป ะฝะฐ ะฒะพััะพะบ, ะฐ ะทะฐัะตะผ ัะฒะตัะฝัะป ะฝะฐ ัะณ. (ะกะะะ ะะฃะขะฌ/ะกะะะ ะะงะะะะขะฌ/ะะะะะ ะะฃะขะฌ/ะะะะะ ะะงะะะะขะฌ)
rus_verbs:ะกะะะ ะะงะะะะขะฌ{}, // //
rus_verbs:ะะะะะ ะะฃะขะฌ{}, //
rus_verbs:ะะะะะ ะะงะะะะขะฌ{}, //
rus_verbs:ะฝะฐะพัะฐัั{},
rus_verbs:ะะ ะะะะะะฃะขะฌะกะฏ{}, // ะะพะปะบ ะฟัะพะดะฒะธะฝะตััั ะฝะฐ ะดะตัััะบะธ ะบะธะปะพะผะตััะพะฒ (ะะ ะะะะะะฃะขะฌะกะฏ)
rus_verbs:ะะ ะะกะะขะฌ{}, // ะะฝ ะฑัะพัะฐะตั ะพะฑะตัะฐะฝะธั ะฝะฐ ะฒะตัะตั (ะะ ะะกะะขะฌ)
rus_verbs:ะะะะะะะขะฌ{}, // ะฏ ะฒะฐะผ ะพะดะพะปะถั ะบะฝะธะณั ะฝะฐ ะดะตัััั ะดะฝะตะน (ะะะะะะะขะฌ)
rus_verbs:ะฟะตัะตะณะฝะฐัั{}, // ะกะบะพั ะฝัะถะฝะพ ะฟะตัะตะณะฝะฐัั ั ััะพะณะพ ะฟะฐััะฑะธัะฐ ะฝะฐ ะดััะณะพะต
rus_verbs:ะฟะตัะตะณะพะฝััั{},
rus_verbs:ะฒัะณะพะฝััั{},
rus_verbs:ะฒัะณะฝะฐัั{},
rus_verbs:ะกะะะะะขะฌะกะฏ{}, // ัะตะนัะฐั ะฟะฐะฝะตะปะธ ะบัะทะพะฒะพะฒ ัะฐัั
ะพะดัััั ะฟะพ ะดะตัััะบะฐะผ ะฟะพะบัะฐัะพัะฝัั
ะฟะพััะพะฒ ะธ ะฟะพัะพะผ ัะฒะพะดัััั ะฒะฝะพะฒั ะฝะฐ ะพะฑัะธะน ะบะพะฝะฒะตะนะตั (ะกะะะะะขะฌะกะฏ)
rus_verbs:ะะะะะ ะขะะะะะขะฌ{}, // ะัะฒัะธะน ััะฝะบัะธะพะฝะตั ะบะพะผะฟะฐััะธะธ ะญััะพะฝะธะธ ะฟะพะถะตััะฒะพะฒะฐะป ะดะตะฝัะณะธ ะฝะฐ ัะฐััะปะตะดะพะฒะฐะฝะธั ะฟัะตัััะฟะปะตะฝะธะน ะบะพะผะผัะฝะธะทะผะฐ (ะะะะะ ะขะะะะะขะฌ)
rus_verbs:ะะ ะะะะ ะฏะขะฌ{}, // ะจะบะพะปัะฝะธะบะพะฒ ะฑัะดัั ะฟัะธะฝัะดะธัะตะปัะฝะพ ะฟัะพะฒะตัััั ะฝะฐ ะบััะตะฝะธะต (ะะ ะะะะ ะฏะขะฌ)
rus_verbs:ะะขะะฃะกะขะะขะฌ{}, // ะัะธััะฐะฒั ะพัะฟััััั ะดะพะปะถะฝะธะบะพะฒ ะฝะฐ ะพัะดัั
(ะะขะะฃะกะขะะขะฌ)
rus_verbs:ะธัะฟะพะปัะทะพะฒะฐัััั{}, // ะธะผะตััะธะนัั ั ะณะพััะดะฐัััะฒะฐ ะดะตะฝะตะถะฝัะน ะทะฐะฟะฐั ะฐะบัะธะฒะฝะพ ะธัะฟะพะปัะทัะตััั ะฝะฐ ะฟะพะดะดะตัะถะฐะฝะธะต ััะฝะบะฐ ะฐะบัะธะน
rus_verbs:ะฝะฐะทะฝะฐัะฐัััั{}, // ะฝะฐะทะฝะฐัะฐัััั ะฝะฐ ะฟะพัั
rus_verbs:ะฝะฐะฑะปัะดะฐัั{}, // ะกัะดัั , ะดะพะปะณะพ ะฝะฐะฑะปัะดะฐะฒัะธะน ะฒ ัััะฑั , ะฒะดััะณ ะฒัะบัะธัะฐะป
rus_verbs:ะจะะะะะะขะฌ{}, // ะะฐะฝะฐะดัะบะพะณะพ ะพัะธัะตัะฐ, ัะฟะธะพะฝะธะฒัะตะณะพ ะฝะฐ ะ ะพััะธั, ะฟัะธะณะพะฒะพัะธะปะธ ะบ 20 ะณะพะดะฐะผ ััััะผั (ะจะะะะะะขะฌ ะะ ะฒะธะฝ)
rus_verbs:ะะะะะะะะ ะะะะขะฌ{}, // ะฒัะต ะดะตะฝัะณะธ , ะทะฐะฟะปะฐะฝะธัะพะฒะฐะฝะฝัะต ะฝะฐ ัะตะนัะผะพัะบัะตะฟะปะตะฝะธะต ะดะพะผะพะฒ ะฝะฐ ะะฐะผัะฐัะบะต (ะะะะะะะะ ะะะะขะฌ ะะ)
// rus_verbs:ะะะฅะะะะขะฌ{}, // ะฑะพะปััะต ะฟะพั
ะพะดะธะป ะฝะฐ ะพะฑะฒะธะฝะธัะตะปัะฝัั ัะตัั , ะฐะดัะตัะพะฒะฐะฝะฝัั ััะบะพะฒะพะดััะฒั ัะตัะฟัะฑะปะธะบะธ (ะะะฅะะะะขะฌ ะะ)
rus_verbs:ะะะะกะขะะะะะขะฌ{}, // ะฒััะฒะปะตะฝะฝัะน ะบะพะฝััะฐะฑะฐะฝะดะฝัะน ะบะฐะฝะฐะป ะดะตะนััะฒะพะฒะฐะป ะฝะฐ ะฟะพััะพัะฝะฝะพะน ะพัะฝะพะฒะต (ะะะะกะขะะะะะขะฌ ะะ)
rus_verbs:ะะะ ะะะะขะฌ{}, // ะฟะพัะปะต ัะตะณะพ ะดะพะปะถะฝะพ ะฑััั ะฟะตัะตะดะฐะฝะพ ะฝะฐ ัะฐััะผะพััะตะฝะธะต ััะดะฐ (ะะะ ะะะะขะฌ ะะ ะฒะธะฝ)
rus_verbs:ะะะะะะงะะขะฌะกะฏ{}, // ะะธะผะพะน ะฝะฐ ััั ะดะพะปะถะฝะพััั ะฟััะฐะปัั ะฝะฐะทะฝะฐัะธัััั ะฝะฐัะพะดะฝัะน ะดะตะฟััะฐั (ะะะะะะงะะขะฌะกะฏ ะะ)
rus_verbs:ะ ะะจะะขะฌะกะฏ{}, // ะคัะฐะฝัะธั ัะตัะธะปะฐัั ะฝะฐ ะพะดะฝะพััะพัะพะฝะฝะตะต ะธ ัะธัะบะพะฒะฐะฝะฝะพะต ะฒะพะตะฝะฝะพะต ะฒะผะตัะฐัะตะปัััะฒะพ (ะ ะะจะะขะฌะกะฏ ะะ)
rus_verbs:ะะ ะะะะขะะ ะะะะขะฌ{}, // ะญัะพั ะฑัะฐัะทะตั ะฟะพะปะฝะพัััั ะพัะธะตะฝัะธัะพะฒะฐะฝ ะฝะฐ ะฟะปะฐะฝัะตัั ะธ ัะตะฝัะพัะฝัะน ะฒะฒะพะด (ะะ ะะะะขะะ ะะะะขะฌ ะะ ะฒะธะฝ)
rus_verbs:ะะะะะกะขะ{}, // ะฝะฐ ะะธััะบั ะทะฐะฒะตะปะธ ะดะตะปะพ (ะะะะะกะขะ ะะ)
rus_verbs:ะะะ ะฃะจะะขะฌะกะฏ{}, // ะ ะกะตะฒะตัะฝะพะน ะัะตัะธะธ ะฝะฐ ะฒะพะธะฝัะบัั ัะฐััั ะพะฑัััะธะปะฐัั ัะฝะตะถะฝะฐั ะปะฐะฒะธะฝะฐ (ะะะ ะฃะจะะขะฌะกะฏ ะ, ะะ)
rus_verbs:ะะะกะขะ ะะะะะขะฌะกะฏ{}, // ะณะตัะตัะพะดะธะฝ, ะฝะฐัััะฐะธะฒะฐััะธะนัั ะฝะฐ ะฒะพะปะฝั (ะะะกะขะ ะะะะะขะฌะกะฏ ะะ)
rus_verbs:ะกะฃะฉะะกะขะะะะะขะฌ{}, // ะะฝ ัััะตััะฒัะตั ะฝะฐ ััะตะดััะฒะฐ ัะพะดะธัะตะปะตะน. (ะกะฃะฉะะกะขะะะะะขะฌ ะะ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฟะพัะพะฑะฝัะน{}, // ะะฝ ัะฟะพัะพะฑะตะฝ ะฝะฐ ัะฑะธะนััะฒะพ. (ะกะะะกะะะะซะ ะะ)
rus_verbs:ะฟะพััะฟะฐัััั{}, // ะฝะฐ ะะธะฝั ะฟะพััะฟะฐะปะธัั ัะฝะตะถะธะฝะบะธ
ะธะฝัะธะฝะธัะธะฒ:ะฝะฐัะตะทะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฃัะพะถะฐะน ัะพะฑะธัะฐัั ะผะตั
ะฐะฝะธัะตัะบะธ ะธะปะธ ะฒัััะฝัั, ััะตะฑะปะธ ะฝะฐัะตะทะฐัััั ะฝะฐ ะบััะบะธ ะธ ะฑััััะพ ััะฐะฝัะฟะพััะธัััััั ะฝะฐ ะฟะตัะตัะฐะฑะฐััะฒะฐััะธะน ะทะฐะฒะพะด.
ะณะปะฐะณะพะป:ะฝะฐัะตะทะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ะฟะพะถะฐะปะพะฒะฐัั{}, // ัะบะฐะฝะดะฐะปัะฝะพ ะธะทะฒะตััะฝัะน ะฟะตะฒะตั ะฟะพะถะฐะปะพะฒะฐะป ะบ ะฝะฐะผ ะฝะฐ ะฟะตัะตะดะฐัั
rus_verbs:ะฟะพะบะฐะทะฐัั{}, // ะะฐะดะธะผ ะฟะพะบะฐะทะฐะป ะฝะฐ ะะพะปั
rus_verbs:ััะตั
ะฐัััั{}, // ะคะธะฝะฐะปะธััั ััะตั
ะฐะปะธัั ะฝะฐ ัะฒะพะธ ะธะณัั ะฒ ะะพั-ะะฝะถะตะปะตั. (ะกะชะะฅะะขะฌะกะฏ ะะ, ะ)
rus_verbs:ัะฐััะตะฟะปััััั{}, // ะกะฐั
ะฐัะพะทะฐ ะถะต ะฑััััะพ ัะฐััะตะฟะปัะตััั ะฒ ะฟะธัะตะฒะฐัะธัะตะปัะฝะพะผ ััะฐะบัะต ะฝะฐ ะณะปัะบะพะทั ะธ ัััะบัะพะทั (ะ ะะกะฉะะะะฏะขะฌะกะฏ ะ, ะะ)
rus_verbs:ัะฟะฐััั{}, // ะ ะขะฐะธะปะฐะฝะดะต ะฝะฐ ะฐะฒัะพะฑัั ั ัะพััะธะนัะบะธะผะธ ัััะธััะฐะผะธ ัะฟะฐะป ะฑะฐัะตะฝะฝัะน ะบัะฐะฝ (ะฃะะะกะขะฌ ะ, ะะ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ััะณะพะน{}, // ะะฐะฑััะบะฐ ััะณะฐ ะฝะฐ ัั
ะพ. (ะขะฃะะะ ะะ)
rus_verbs:ัะฒะธัะฐัั{}, // ะะพะปะพัั ัะฒะธัะฐัั ะฝะฐ ะปะพะฑ. (ัะฒะธัะฐัั ะฝะฐ)
rus_verbs:ะฆะะะะขะฌะกะฏ{}, // ะััะบะฐั ัะฐะฑะพัะฐั ััะบะฐ ัะตะฝะธะปะฐัั ะฝะฐ ะฒะตั ะทะพะปะพัะฐ. (ะฆะะะะขะฌะกะฏ ะะ)
rus_verbs:ะจะฃะะะขะฌ{}, // ะั ััะผะธัะต ะฝะฐ ะฒะตัั ะดะพะผ! (ะจะฃะะะขะฌ ะะ)
rus_verbs:ะฟัะพััะฝััััั{}, // ะะพัะพะณะฐ ะฟัะพััะฝัะปะฐัั ะฝะฐ ัะพัะฝะธ ะบะธะปะพะผะตััะพะฒ. (ะฟัะพััะฝััััั ะฝะฐ)
rus_verbs:ะ ะะกะกะงะะขะะขะฌ{}, // ะะฝะธะณะฐ ัะฐัััะธัะฐะฝะฐ ะฝะฐ ะผะฐััะพะฒะพะณะพ ัะธัะฐัะตะปั. (ะ ะะกะกะงะะขะะขะฌ ะะ)
rus_verbs:ะกะะ ะะะะขะะ ะะะะขะฌ{}, // ะผั ัะพัะธะตะฝัะธัะพะฒะฐะปะธ ะฟัะพัะตัั ะฝะฐ ะฟะพะฒััะตะฝะธะต ะบะพัะธัะพะฒะพะบ (ะกะะ ะะะะขะะ ะะะะขะฌ ะะ)
rus_verbs:ััะบะฝััั{}, // ััะบะฝััั ะฝะฐ ะพััะฐะปัะฝัั
ัะปะตะฝะพะฒ ััะฐะธ (ััะบะฝััั ะฝะฐ)
rus_verbs:ะพะบะฐะฝัะธะฒะฐัััั{}, // ะพะบะฐะฝัะธะฒะฐัััั ะฝะฐ ะทะฒะพะฝะบัั ัะพะณะปะฐัะฝัั (ะพะบะฐะฝัะธะฒะฐัััั ะฝะฐ)
rus_verbs:ะฒัะตั
ะฐัั{}, // ะฟะพัะธะณะฝะฐะปะธัั ะฝะฐัััะธัะตะปั, ะฒัะตั
ะฐะฒัะตะผั ะฝะฐ ะฒัััะตัะฝัั ะฟะพะปะพัั (ะฒัะตั
ะฐัั ะฝะฐ)
rus_verbs:ะฟัะธะนัะธัั{}, // ะััะพะต ัะธัะปะพ ะฟัะธัะปะพัั ะฝะฐ ััะฑะฑะพัั.
rus_verbs:ะบัะตะฝะธัััั{}, // ะบะพัะฐะฑะปั ะบัะตะฝะธะปัั ะฝะฐ ะฟัะฐะฒัะน ะฑะพัั (ะบัะตะฝะธัััั ะฝะฐ)
rus_verbs:ะฟัะธั
ะพะดะธัััั{}, // ะพัะฝะพะฒะฝะพะน ะฝะฐะปะพะณะพะฒัะน ะณะฝะตั ะฟัะธั
ะพะดะธััั ะฝะฐ ััะตะดะฝะธะน ะฑะธะทะฝะตั (ะฟัะธั
ะพะดะธัััั ะฝะฐ)
rus_verbs:ะฒะตัะธัั{}, // ะฒะตัะธัั ะปัะดัะผ ะฝะฐ ัะปะพะฒะพ (ะฒะตัะธัั ะฝะฐ ัะปะพะฒะพ)
rus_verbs:ะฒัะตะทะถะฐัั{}, // ะะฐะฒััะฐ ะฒัั ัะตะผัั ะฒัะตะทะถะฐะตั ะฝะฐ ะฝะพะฒัั ะบะฒะฐััะธัั.
rus_verbs:ะทะฐะฟะธัะฐัั{}, // ะะฐะฟะธัะธัะต ะผะตะฝั ะฝะฐ ะทะฐะฒััะฐัะฝะธะน ะฟัะธัะผ ะบ ะดะพะบัะพัั.
rus_verbs:ะฟะฐััั{}, // ะัะตะฑะธะน ะฟะฐะป ะฝะฐ ะผะตะฝั.
rus_verbs:ะตะทะดะธัั{}, // ะัะตัะฐ ะผั ะตะทะดะธะปะธ ะฝะฐ ะพะฟะตัั.
rus_verbs:ะฒะปะตะทัั{}, // ะะฐะปััะธะบ ะฒะปะตะท ะฝะฐ ะดะตัะตะฒะพ.
rus_verbs:ะฒัะฑะตะถะฐัั{}, // ะะฐะปััะธะบ ะฒัะฑะตะถะฐะป ะธะท ะบะพะผะฝะฐัั ะฝะฐ ัะปะธัั.
rus_verbs:ัะฐะทะฑะธัััั{}, // ะพะบะฝะพ ัะฐะทะฑะธะปะพัั ะฝะฐ ะผะตะปะบะธะต ะพัะบะพะปะบะธ
rus_verbs:ะฑะตะถะฐัั{}, // ั ะฑะตะณั ะฝะฐ ััะพะบ
rus_verbs:ัะฑะตะณะฐัััั{}, // ัะฑะตะณะฐัััั ะฝะฐ ะฟัะพะธััะตััะฒะธะต
rus_verbs:ะฟัะธััะปะฐัั{}, // ะฟัะธััะปะฐัั ะฝะฐ ะธัะฟััะฐะฝะธะต
rus_verbs:ะฝะฐะดะฐะฒะธัั{}, // ะฝะฐะดะฐะฒะธัั ะฝะฐ ะฟะตะดะฐัั
rus_verbs:ะฒะฝะตััะธ{}, // ะฒะฝะตััะธ ะทะฐะบะพะฝะพะฟัะพะตะบั ะฝะฐ ัะฐััะผะพััะตะฝะธะต
rus_verbs:ะฒะฝะพัะธัั{}, // ะฒะฝะพัะธัั ะทะฐะบะพะฝะพะฟัะพะตะบั ะฝะฐ ัะฐััะผะพััะตะฝะธะต
rus_verbs:ะฟะพะฒะพัะฐัะธะฒะฐัััั{}, // ะฟะพะฒะพัะฐัะธะฒะฐัััั ะฝะฐ 180 ะณัะฐะดััะพะฒ
rus_verbs:ัะดะฒะธะฝััั{}, // ัะดะฒะธะฝััั ะฝะฐ ะฝะตัะบะพะปัะบะพ ัะฐะฝัะธะผะตััะพะฒ
rus_verbs:ะพะฟัะฑะปะธะบะพะฒะฐัั{}, // ะก.ะะธััะพั
ะธะฝ ะพะฟัะฑะปะธะบะพะฒะฐะป ะบะพะผะฟัะพะผะฐั ะฝะฐ ะดัะผัะบะธั
ะฟะพะดะตะปัะฝะธะบะพะฒ ะัะดะบะพะฒะฐ
rus_verbs:ะฒััะฐััะธ{}, // ะัะธัะธะฐะปัะฝัะน ะบััั ะดะพะปะปะฐัะฐ ะฒััะพั ะฝะฐ 26 ะบะพะฟะตะตะบ.
rus_verbs:ะพะณะปัะดัะฒะฐัััั{}, // ะพะณะปัะดัะฒะฐัััั ะฝะฐ ะดะตะฒััะตะบ
rus_verbs:ัะฐัั
ะพะดะธัััั{}, // ัะฐัั
ะพะดะธัััั ะฝะฐ ะพัะดัั
rus_verbs:ะฟะพัะบะฐะบะฐัั{}, // ะฟะพัะบะฐะบะฐัั ะฝะฐ ัะปัะถะฑั
rus_verbs:ะฟััะณะฐัั{}, // ะฟััะณะฐัั ะฝะฐ ััะตะฝั
rus_verbs:ะฟัะธะณะปะฐัะฐัั{}, // ะฟัะธะณะปะฐัะฐัั ะฝะฐ ะพะฑะตะด
rus_verbs:ัะฒะฐัััั{}, // ะััะพะบ ัะบะฐะฝะธ ัะฒะตััั ะฝะฐ ัะฐััะธ
rus_verbs:ะฟะพะฝะตััะธัั{}, // ะฟะพะฝะตััะธัั ะฝะฐ ะฒะพะปั
rus_verbs:ัะฐัะฟัะพัััะฐะฝััััั{}, // ัะฐัะฟัะพัััะฐะฝััััั ะฝะฐ ะฒัะตั
ะถะธัะตะปะตะน ััะฐัะฐ
ะธะฝัะธะฝะธัะธะฒ:ะฟัะพััะฟะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฟัะพััะฟะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, // ะฟัะพััะฟะฐัััั ะฝะฐ ะฟะพะป
ะธะฝัะธะฝะธัะธะฒ:ะฟัะพััะฟะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะฟัะพััะฟะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะฟัะพััะฟะฐะฒัะธัั{}, ะดะตะตะฟัะธัะฐััะธะต:ะฟัะพััะฟะฐััั{},
rus_verbs:ะทะฐะตั
ะฐัั{}, // ะทะฐะตั
ะฐัั ะฝะฐ ะฟะฐะฝะดัั
rus_verbs:ัะฐะทะพะฑัะฐัั{}, // ัะฐะทะพะฑัะฐัั ะฝะฐ ัะพััะฐะฒะปัััะธะต
rus_verbs:ะพะฟััะบะฐัััั{}, // ะพะฟััะบะฐัััั ะฝะฐ ะบะพะปะตะฝะธ
rus_verbs:ะฟะตัะตะตั
ะฐัั{}, // ะฟะตัะตะตั
ะฐัั ะฝะฐ ะบะพะฝัะฟะธัะฐัะธะฒะฝัั ะบะฒะฐััะธัั
rus_verbs:ะทะฐะบััะฒะฐัั{}, // ะทะฐะบััะฒะฐัั ะณะปะฐะทะฐ ะฝะฐ ะดะตะนััะฒะธั ะบะพะฝะบััะตะฝัะพะฒ
rus_verbs:ะฟะพะผะตััะธัั{}, // ะฟะพะผะตััะธัั ะฝะฐ ะฟะพะดะฝะพั
rus_verbs:ะพัั
ะพะดะธัั{}, // ะพัั
ะพะดะธัั ะฝะฐ ะฟะพะดะณะพัะพะฒะปะตะฝะฝัะต ะฟะพะทะธัะธะธ
rus_verbs:ััะฟะฐัััั{}, // ััะฟะฐัััั ะฝะฐ ะฟะปะตัะธ
rus_verbs:ะพัะฒะตะทัะธ{}, // ะพัะฒะตะทัะธ ะฝะฐ ะทะฐะฝััะธั
rus_verbs:ะฝะฐะบะธะฝััั{}, // ะฝะฐะบะธะฝััั ะฝะฐ ะฟะปะตัะธ
rus_verbs:ะพัะปะตัะตัั{}, // ะพัะปะตัะตัั ะฝะฐ ะฟะพะป
rus_verbs:ะทะฐะบะธะฝััั{}, // ะทะฐะบะธะฝััั ะฝะฐ ัะตัะดะฐะบ
rus_verbs:ะทะฐัะธะฟะตัั{}, // ะทะฐัะธะฟะตัั ะฝะฐ ัะพะฑะฐะบั
rus_verbs:ะฟัะพะณัะตะผะตัั{}, // ะฟัะพะณัะตะผะตัั ะฝะฐ ะฒัั ัััะฐะฝั
rus_verbs:ะฟะพะฒะฐะปะธัั{}, // ะฟะพะฒะฐะปะธัั ะฝะฐ ััะพะป
rus_verbs:ะพะฟะตัะตัั{}, // ะพะฟะตัะตัั ะฝะฐ ััะฝะดะฐะผะตะฝั
rus_verbs:ะทะฐะฑัะพัะธัั{}, // ะทะฐะฑัะพัะธัั ะฝะฐ ะฐะฝััะตัะพะปั
rus_verbs:ะฟะพะดะตะนััะฒะพะฒะฐัั{}, // ะฟะพะดะตะนััะฒะพะฒะฐัั ะฝะฐ ะผะฐัะตัะธะฐะป
rus_verbs:ัะฐะทะดะตะปััั{}, // ัะฐะทะดะตะปััั ะฝะฐ ัะฐััะธ
rus_verbs:ะฟัะธะบัะธะบะฝััั{}, // ะฟัะธะบัะธะบะฝััั ะฝะฐ ะดะตัะตะน
rus_verbs:ัะฐะทะปะพะถะธัั{}, // ัะฐะทะปะพะถะธัั ะฝะฐ ะผะฝะพะถะธัะตะปะธ
rus_verbs:ะฟัะพะฒะพะถะฐัั{}, // ะฟัะพะฒะพะถะฐัั ะฝะฐ ัะฐะฑะพัั
rus_verbs:ะบะฐัะธัั{}, // ะบะฐัะธัั ะฝะฐ ัััะพะนะบั
rus_verbs:ะฝะฐะปะพะถะธัั{}, // ะฝะฐะปะพะถะธัั ะทะฐะฟัะตั ะฝะฐ ะฟัะพะฒะตะดะตะฝะธะต ะพะฟะตัะฐัะธะน ั ะฝะตะดะฒะธะถะธะผะพัััั
rus_verbs:ัะพั
ัะฐะฝััั{}, // ัะพั
ัะฐะฝััั ะฝะฐ ะฟะฐะผััั
rus_verbs:ะทะปะธัััั{}, // ะทะปะธัััั ะฝะฐ ะดััะณะฐ
rus_verbs:ะพะฑะพัะฐัะธะฒะฐัััั{}, // ะพะฑะพัะฐัะธะฒะฐัััั ะฝะฐ ัะฒะธัั
rus_verbs:ัะฟะพะปะทัะธ{}, // ัะฟะพะปะทัะธ ะฝะฐ ะทะตะผะปั
rus_verbs:ะทะฐะฟะธััะฒะฐัั{}, // ะทะฐะฟะธััะฒะฐัั ะฝะฐ ะปะตะฝัั
rus_verbs:ะทะฐะณะฝะฐัั{}, // ะทะฐะณะฝะฐัั ะฝะฐ ะดะตัะตะฒะพ
rus_verbs:ะทะฐะฑะพัะผะพัะฐัั{}, // ะทะฐะฑะพัะผะพัะฐัั ะฝะฐ ัั
ะพ
rus_verbs:ะฟัะพัะธัะฝััััั{}, // ะฟัะพัะธัะฝััััั ะฝะฐ ัะฐะผัะน ะบัะฐะน
rus_verbs:ะทะฐัะพัะพะฟะธัััั{}, // ะทะฐัะพัะพะฟะธัััั ะฝะฐ ะฒัััะตะฝะธะต ะฟัะตะผะธะธ
rus_verbs:ะณะฐัะบะฝััั{}, // ะณะฐัะบะฝััั ะฝะฐ ัะฐะปัะฝะพะฒ
rus_verbs:ะฝะฐะฒะฐะปะธัััั{}, // ะฝะฐะฒะฐะปะธัััั ะฝะฐ ะฒะธะฝะพะฒะฝะธะบะฐ ะฒัะตะน ัะพะปะฟะพะน
rus_verbs:ะฟัะพัะบะพะปัะทะฝััั{}, // ะฟัะพัะบะพะปัะทะฝััั ะฝะฐ ะบัััั ะดะพะผะฐ
rus_verbs:ะฟะพะดััะฝััั{}, // ะฟะพะดััะฝััั ะฝะฐ ะฟะฐะปัะฑั
rus_verbs:ัะบะฐัะธัััั{}, // ัะบะฐัะธัััั ะฝะฐ ะดะฒะพะนะบะธ
rus_verbs:ะดะฐะฒะธัั{}, // ะดะฐะฒะธัั ะฝะฐ ะถะฐะปะพััั
rus_verbs:ะฝะฐะผะตะบะฝััั{}, // ะฝะฐะผะตะบะฝััั ะฝะฐ ะฝะพะฒัะต ะพะฑััะพััะตะปัััะฒะฐ
rus_verbs:ะทะฐะผะฐั
ะฝััััั{}, // ะทะฐะผะฐั
ะฝััััั ะฝะฐ ัะฒััะพะต
rus_verbs:ะทะฐะผะตะฝะธัั{}, // ะทะฐะผะตะฝะธัั ะฝะฐ ัะฒะตะถัั ัะฐะปัะตัะบั
rus_verbs:ัะฒะฐะปะธัั{}, // ัะฒะฐะปะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ััะตะบะฐัั{}, // ััะตะบะฐัั ะฝะฐ ะพะณะพะปะตะฝะฝัะต ะฟัะพะฒะพะดะฐ
rus_verbs:ัะฒะตะปะธัะธะฒะฐัััั{}, // ัะฒะตะปะธัะธะฒะฐัััั ะฝะฐ ัะพัะฝั ะฟัะพัะตะฝัะพะฒ
rus_verbs:ัะฐะทะฒะฐะปะธัััั{}, // ัะฐะทะฒะฐะปะธัััั ะฝะฐ ัะฐััะธ
rus_verbs:ัะตัะดะธัััั{}, // ัะตัะดะธัััั ะฝะฐ ัะพะฒะฐัะธัะฐ
rus_verbs:ะพะฑัะพะฝะธัั{}, // ะพะฑัะพะฝะธัั ะฝะฐ ะฟะพะป
rus_verbs:ะฟะพะดัะตััั{}, // ะฟะพะดัะตััั ะฝะฐ ะฝะฐัะบะพัั
rus_verbs:ัะตะฐะณะธัะพะฒะฐัั{}, // ัะตะฐะณะธัะพะฒะฐัั ะฝะฐ ะธะผะฟัะปััั
rus_verbs:ะพัะฟััะบะฐัั{}, // ะพัะฟััะบะฐัั ะฝะฐ ะฒะพะปั
rus_verbs:ะฟัะพะณะฝะฐัั{}, // ะฟัะพะณะฝะฐัั ะฝะฐ ัะฐะฑะพัะตะต ะผะตััะพ
rus_verbs:ะปะพะถะธัั{}, // ะปะพะถะธัั ะฝะฐ ััะพะป
rus_verbs:ัะฒะฐัั{}, // ัะฒะฐัั ะฝะฐ ัะฐััะธ
rus_verbs:ัะฐะทะปะตัะตัััั{}, // ัะฐะทะปะตัะตัััั ะฝะฐ ะบััะพัะบะธ
rus_verbs:ะฟัะตะฒััะฐัั{}, // ะฟัะตะฒััะฐัั ะฝะฐ ัััะตััะฒะตะฝะฝัั ะฒะตะปะธัะธะฝั
rus_verbs:ัะฑะธัััั{}, // ัะฑะธัััั ะฝะฐ ัััั
rus_verbs:ะฟัะธัััะพะธัััั{}, // ะฟัะธัััะพะธัััั ะฝะฐ ั
ะพัะพััั ัะฐะฑะพัั
rus_verbs:ัะดัะฐัั{}, // ัะดัะฐัั ะฝะฐ ะฟะฐััะฑะธัะต
rus_verbs:ัะพะปะบะฐัั{}, // ัะพะปะบะฐัั ะฝะฐ ะฟัะตัััะฟะปะตะฝะธะต
rus_verbs:ะฟะพัะผะฐััะธะฒะฐัั{}, // ะฟะพัะผะฐััะธะฒะฐัั ะฝะฐ ัะบัะฐะฝ
rus_verbs:ะฝะฐะฑะธัะฐัั{}, // ะฝะฐะฑะธัะฐัั ะฝะฐ ััะดะฝะพ
rus_verbs:ะพััััะฟะฐัั{}, // ะพััััะฟะฐัั ะฝะฐ ะดะตัะตะฒะพ
rus_verbs:ะฟะพะดััั{}, // ะฟะพะดััั ะฝะฐ ะผะพะปะพะบะพ
rus_verbs:ะฟะปะตัะฝััั{}, // ะฟะปะตัะฝััั ะฝะฐ ะณะพะปะพะฒั
rus_verbs:ัะพัะบะพะปัะทะฝััั{}, // ัะพัะบะพะปัะทะฝััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะทะฐัะฐะธัั{}, // ะทะฐัะฐะธัั ะฝะฐ ะบะพะณะพ-ัะพ ะพะฑะธะดั
rus_verbs:ะพะฑะธะถะฐัััั{}, // ะพะฑะธะถะฐัััั ะฝะฐ ะะพะปั
rus_verbs:ัะผะฐั
ะฝััั{}, // ัะผะฐั
ะฝััั ะฝะฐ ะฟะพะป
rus_verbs:ะทะฐััะตะณะฝััั{}, // ะทะฐััะตะณะฝััั ะฝะฐ ะฒัะต ะฟัะณะพะฒะธัั
rus_verbs:ัะฟััะบะฐัั{}, // ัะฟััะบะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะณัะตะผะตัั{}, // ะณัะตะผะตัั ะฝะฐ ะฒัั ะพะบััะณั
rus_verbs:ัะบะพัะธัั{}, // ัะบะพัะธัั ะฝะฐ ัะพัะตะดะฐ ะณะปะฐะท
rus_verbs:ะพัะฒะฐะถะธัััั{}, // ะพัะฒะฐะถะธัััั ะฝะฐ ะฟััะถะพะบ
rus_verbs:ะปะธัััั{}, // ะปะธัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฟะพัะฒะฐัั{}, // ะฟะพัะฒะฐัั ะฝะฐ ัััะฟะบะธ
rus_verbs:ะฟัะพัะปะตะดะพะฒะฐัั{}, // ะฟัะพัะปะตะดะพะฒะฐัั ะฝะฐ ััะตะฝั
rus_verbs:ะฝะฐะดะตะฒะฐัั{}, // ะฝะฐะดะตะฒะฐัั ะฝะฐ ะณะพะปะพะฒั
rus_verbs:ะฟัะพัะบะพัะธัั{}, // ะฟัะพัะบะพัะธัั ะฝะฐ ะบัะฐัะฝัะน ัะฒะตั
rus_verbs:ะฟัะธะปะตัั{}, // ะฟัะธะปะตัั ะฝะฐ ะดะธะฒะฐะฝัะธะบ
rus_verbs:ัะฐะทะดะตะปะธัััั{}, // ัะฐะทะดะตะปะธัััั ะฝะฐ ะฝะตะฑะพะปััะธะต ะณััะฟะฟั
rus_verbs:ะทะฐะฒััั{}, // ะทะฐะฒััั ะฝะฐ ะปัะฝั
rus_verbs:ะฟะตัะตะฝะพัะธัั{}, // ะฟะตัะตะฝะพัะธัั ะฝะฐ ะดััะณัั ะผะฐัะธะฝั
rus_verbs:ะฝะฐะณะพะฒะพัะธัั{}, // ะฝะฐะณะพะฒะพัะธัั ะฝะฐ ัะพัะฝั ััะฑะปะตะน
rus_verbs:ะฝะฐะผะตะบะฐัั{}, // ะฝะฐะผะตะบะฐัั ะฝะฐ ะฝะพะฒัะต ะพะฑััะพััะตะปัััะฒะฐ
rus_verbs:ะฝะฐะฟะฐะดะฐัั{}, // ะฝะฐะฟะฐะดะฐัั ะฝะฐ ะพั
ัะฐะฝะฝะธะบะพะฒ
rus_verbs:ัะฑะตะณะฐัั{}, // ัะฑะตะณะฐัั ะฝะฐ ะดััะณะพะต ะผะตััะพ
rus_verbs:ััะฐัะธัั{}, // ััะฐัะธัั ะฝะฐ ัะฐะทะฒะปะตัะตะฝะธั
rus_verbs:ะฟัะธัะฐะถะธะฒะฐัััั{}, // ะฟัะธัะฐะถะธะฒะฐัััั ะฝะฐ ะบะพััะพัะบะธ
rus_verbs:ะฟะตัะตะผะตััะธัััั{}, // ะฟะตัะตะผะตััะธัััั ะฝะฐ ะฒัะพััั ะปะธะฝะธั
rus_verbs:ะทะฐะฒะฐะปะธัััั{}, // ะทะฐะฒะฐะปะธัััั ะฝะฐ ะดะธะฒะฐะฝ
rus_verbs:ัะดะฐะปะธัััั{}, // ัะดะฐะปะธัััั ะฝะฐ ะฟะพะบะพะน
rus_verbs:ัะผะตะฝััะฐัััั{}, // ัะผะตะฝััะฐัััั ะฝะฐ ะฝะตัะบะพะปัะบะพ ะฟัะพัะตะฝัะพะฒ
rus_verbs:ะพะฑัััะธัั{}, // ะพะฑัััะธัั ะฝะฐ ะณะพะปะพะฒั
rus_verbs:ัะตะทะฐัั{}, // ัะตะทะฐัั ะฝะฐ ัะฐััะธ
rus_verbs:ัะผัะฐัััั{}, // ัะผัะฐัััั ะฝะฐ ัะณ
rus_verbs:ะฝะฐะฒะตัะฝััััั{}, // ะฝะฐะฒะตัะฝััััั ะฝะฐ ะบะฐะผะตะฝั
rus_verbs:ะฟัะธะผัะฐัััั{}, // ะฟัะธะผัะฐัััั ะฝะฐ ะผะฐัั
rus_verbs:ะธะทะดะฐะฒะฐัั{}, // ะธะทะดะฐะฒะฐัั ะฝะฐ ัะพะฑััะฒะตะฝะฝัะต ััะตะดััะฒะฐ
rus_verbs:ะฟะตัะตะบะปััะธัั{}, // ะฟะตัะตะบะปััะธัั ะฝะฐ ะดััะณะพะน ัะทัะบ
rus_verbs:ะพัะฟัะฐะฒะปััั{}, // ะพัะฟัะฐะฒะปััั ะฝะฐ ะฟะตะฝัะธั
rus_verbs:ะทะฐะปะตัั{}, // ะทะฐะปะตัั ะฝะฐ ะดะฝะพ
rus_verbs:ัััะฐะฝะพะฒะธัััั{}, // ัััะฐะฝะพะฒะธัััั ะฝะฐ ะดะธัะบ
rus_verbs:ะฝะฐะฟัะฐะฒะปััั{}, // ะฝะฐะฟัะฐะฒะปััั ะฝะฐ ะดะพะฟะพะปะฝะธัะตะปัะฝะพะต ะพะฑัะปะตะดะพะฒะฐะฝะธะต
rus_verbs:ัะฐะทัะตะทะฐัั{}, // ัะฐะทัะตะทะฐัั ะฝะฐ ัะฐััะธ
rus_verbs:ะพัะบะฐะปะธัััั{}, // ะพัะบะฐะปะธัััั ะฝะฐ ะฟัะพั
ะพะถะตะณะพ
rus_verbs:ัััะฐัั{}, // ัััะฐัั ะฝะฐ ะฟััะฝัั
rus_verbs:ะฟะพะณััะถะฐัััั{}, // ะฟะพะณััะถะฐัััั ะฝะฐ ะดะฝะพ
rus_verbs:ะพะฟะธัะฐัััั{}, // ะพะฟะธัะฐัััั ะฝะฐ ะบะพัััะปะธ
rus_verbs:ะฟะพัะพัะพะฟะธัััั{}, // ะฟะพัะพัะพะฟะธัััั ะฝะฐ ััะตะฑั
rus_verbs:ัะดะฒะธะฝััััั{}, // ัะดะฒะธะฝััััั ะฝะฐ ัะฐะฝัะธะผะตัั
rus_verbs:ัะฒะตะปะธัะธัั{}, // ัะฒะตะปะธัะธัั ะฝะฐ ะฟัะพัะตะฝั
rus_verbs:ะพะฟััะบะฐัั{}, // ะพะฟััะบะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะพะทะฒะฐัั{}, // ัะพะทะฒะฐัั ะฝะฐ ะผะธัะธะฝะณ
rus_verbs:ะดะตะปะธัั{}, // ะดะตะปะธัั ะฝะฐ ัะฐััะธ
rus_verbs:ะฟัะพะฑะธัััั{}, // ะฟัะพะฑะธัััั ะฝะฐ ะทะฐะบะปััะธัะตะปัะฝัั ัะฐััั
rus_verbs:ะฟัะพััะธัะฐัััั{}, // ะฟัะพััะธัะฐัััั ะฝะฐ ะผะฝะพะณะพ ะผะธะปั
rus_verbs:ะทะฐะฑะธัั{}, // ะทะฐะฑะธัั ะฝะฐ ััะตะฑั
rus_verbs:ะฟะตัะตะปะพะถะธัั{}, // ะฟะตัะตะปะพะถะธัั ะฝะฐ ััะถะธะต ะฟะปะตัะธ
rus_verbs:ะณัะพั
ะฝััััั{}, // ะณัะพั
ะฝััััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฟัะพัะฒะฐัััั{}, // ะฟัะพัะฒะฐัััั ะฝะฐ ััะตะฝั
rus_verbs:ัะฐะทะปะธัั{}, // ัะฐะทะปะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะบะปะฐะดัะฒะฐัััั{}, // ัะบะปะฐะดัะฒะฐัััั ะฝะฐ ะฝะพัะตะฒะบั
rus_verbs:ัะฒะพะปะธัั{}, // ัะฒะพะปะธัั ะฝะฐ ะฟะตะฝัะธั
rus_verbs:ะฝะฐะฝะพัะธัั{}, // ะฝะฐะฝะพัะธัั ะฝะฐ ะบะพะถั
rus_verbs:ะฝะฐะฑะตะถะฐัั{}, // ะฝะฐะฑะตะถะฐัั ะฝะฐ ะฑะตัะตะณ
rus_verbs:ะทะฐัะฒะธัััั{}, // ะทะฐัะฒะธัััั ะฝะฐ ัััะตะปัะฑะธัะต
rus_verbs:ะฝะฐะปะธัััั{}, // ะฝะฐะปะธัััั ะฝะฐ ะบัััะบั
rus_verbs:ะฝะฐะดะฒะธะณะฐัััั{}, // ะฝะฐะดะฒะธะณะฐัััั ะฝะฐ ะฑะตัะตะณ
rus_verbs:ัะฐัะฟัััะธัั{}, // ัะฐัะฟัััะธัั ะฝะฐ ะบะฐะฝะธะบัะปั
rus_verbs:ะฟะตัะตะบะปััะธัััั{}, // ะฟะตัะตะบะปััะธัััั ะฝะฐ ะดััะณัั ะทะฐะดะฐัั
rus_verbs:ัะธั
ะฝััั{}, // ัะธั
ะฝััั ะฝะฐ ะพะบััะถะฐััะธั
rus_verbs:ัะปะตะฟะฝััััั{}, // ัะปะตะฟะฝััััั ะฝะฐ ัะฟะธะฝั
rus_verbs:ัััะฐะฝะฐะฒะปะธะฒะฐัั{}, // ัััะฐะฝะฐะฒะปะธะฒะฐัั ะฝะฐ ะบัััั
rus_verbs:ัััะฐะฝะฐะฒะปะธะฒะฐัััั{}, // ัััะฐะฝะฐะฒะปะธะฒะฐัััั ะฝะฐ ะบัััั
rus_verbs:ััััะฐะธะฒะฐัััั{}, // ััััะฐะธะฒะฐัััั ะฝะฐ ัะฐะฑะพัั
rus_verbs:ะฟัะพะฟััะบะฐัั{}, // ะฟัะพะฟััะบะฐัั ะฝะฐ ััะฐะดะธะพะฝ
ะธะฝัะธะฝะธัะธะฒ:ัะฑะตะณะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฑะตะณะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะฑะตะณะฐัั ะฝะฐ ัะธะปัะผ
ะธะฝัะธะฝะธัะธะฒ:ัะฑะตะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฑะตะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ัะฑะตะณะฐะฒ{}, ะดะตะตะฟัะธัะฐััะธะต:ัะฑะตะณะฐั{},
rus_verbs:ะฟะพะบะฐะทัะฒะฐัััั{}, // ะฟะพะบะฐะทัะฒะฐัััั ะฝะฐ ะณะปะฐะทะฐ
rus_verbs:ะฟัะธะฑะตะณะฐัั{}, // ะฟัะธะฑะตะณะฐัั ะฝะฐ ััะพะบ
rus_verbs:ััะตะทะดะธัั{}, // ััะตะทะดะธัั ะฝะฐ ัะตัะผั
rus_verbs:ะฟัะพัะปะฐะฒะธัััั{}, // ะฟัะพัะปะฐะฒะธัััั ะฝะฐ ะฒัั ัััะฐะฝั
rus_verbs:ะพะฟัะพะบะธะฝััััั{}, // ะพะฟัะพะบะธะฝััััั ะฝะฐ ัะฟะธะฝั
rus_verbs:ะฝะฐััะฟะฐัั{}, // ะฝะฐััะฟะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะฟะพััะตะฑะปััั{}, // ัะฟะพััะตะฑะปััั ะฝะฐ ะบะพัะผ ัะบะพัั
rus_verbs:ะฟัะธัััะพะธัั{}, // ะฟัะธัััะพะธัั ะฝะฐ ัะฐะฑะพัั
rus_verbs:ะทะฐะฒะพััะฐัั{}, // ะทะฐะฒะพััะฐัั ะฝะฐ ะฒะพัะตะดัะตะณะพ
rus_verbs:ะทะฐะฒัะทะฐัััั{}, // ะทะฐะฒัะทะฐัััั ะฝะฐ ะฟะพััะฐะฒัะธะบะพะฒ
rus_verbs:ัะฐะถะฐัั{}, // ัะฐะถะฐัั ะฝะฐ ัััะป
rus_verbs:ะฝะฐะฟัะฐัะธะฒะฐัััั{}, // ะฝะฐะฟัะฐัะธะฒะฐัััั ะฝะฐ ะถะตััะบะธะต ะพัะฒะตัะฝัะต ะผะตัั
rus_verbs:ะทะฐะผะตะฝััั{}, // ะทะฐะผะตะฝััั ะฝะฐ ะธัะฟัะฐะฒะฝัั
rus_verbs:ะฝะฐัะตะฟะธัั{}, // ะฝะฐัะตะฟะธัั ะฝะฐ ะณะพะปะพะฒั
rus_verbs:ััะฟะฐัั{}, // ััะฟะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะทะฐะบััะฒะฐัััั{}, // ะทะฐะบััะฒะฐัััั ะฝะฐ ัะตะผะพะฝั
rus_verbs:ัะฐัะฟัะพัััะฐะฝะธัััั{}, // ัะฐัะฟัะพัััะฐะฝะธัััั ะฝะฐ ะฒัั ะฟะพะฟัะปััะธั
rus_verbs:ะฟะพะผะตะฝััั{}, // ะฟะพะผะตะฝััั ะฝะฐ ะฒะตะปะพัะธะฟะตะด
rus_verbs:ะฟะตัะตัะตััั{}, // ะฟะตัะตัะตััั ะฝะฐ ะฒะตะปะพัะธะฟะตะดั
rus_verbs:ะฟะพะดะพัะฟะตัั{}, // ะฟะพะดะพัะฟะตัั ะฝะฐ ัะฐะทะฑะพั
rus_verbs:ัะธะฟะตัั{}, // ัะธะฟะตัั ะฝะฐ ัะพะฑะฐะบ
rus_verbs:ะฟะพะดะตะปะธัั{}, // ะฟะพะดะตะปะธัั ะฝะฐ ัะฐััะธ
rus_verbs:ะฟะพะดะปะตัะตัั{}, // ะฟะพะดะปะตัะตัั ะฝะฐ ัะฐัััะพัะฝะธะต ะฒััััะตะปะฐ
rus_verbs:ะฝะฐะถะธะผะฐัั{}, // ะฝะฐะถะธะผะฐัั ะฝะฐ ะฒัะต ะบะฝะพะฟะบะธ
rus_verbs:ัะฐัะฟะฐััััั{}, // ัะฐัะฟะฐััััั ะฝะฐ ัะฐััะธ
rus_verbs:ะฟัะธะฒะพะปะพัั{}, // ะฟัะธะฒะพะปะพัั ะฝะฐ ะดะธะฒะฐะฝ
rus_verbs:ะฟะพะถะธัั{}, // ะฟะพะถะธัั ะฝะฐ ะพะดะธะฝ ะดะพะปะปะฐั
rus_verbs:ััััะตะผะปััััั{}, // ััััะตะผะปััััั ะฝะฐ ัะฒะพะฑะพะดั
rus_verbs:ัะผะฐั
ะธะฒะฐัั{}, // ัะผะฐั
ะธะฒะฐัั ะฝะฐ ะฟะพะป
rus_verbs:ะทะฐะฑะตะถะฐัั{}, // ะทะฐะฑะตะถะฐัั ะฝะฐ ะพะฑะตะด
rus_verbs:ัะฒะตะปะธัะธัััั{}, // ัะฒะตะปะธัะธัััั ะฝะฐ ัััะตััะฒะตะฝะฝัั ะฒะตะปะธัะธะฝั
rus_verbs:ะฟัะพะบัะฐััััั{}, // ะฟัะพะบัะฐััััั ะฝะฐ ัะบะปะฐะด
rus_verbs:ะฟััะฐัั{}, // ะฟััะฐัั ะฝะฐ ะฟะพััะพะน
rus_verbs:ะพัะบะปะพะฝะธัั{}, // ะพัะบะปะพะฝะธัั ะฝะฐ ะฝะตัะบะพะปัะบะพ ะณัะฐะดััะพะฒ
rus_verbs:ะฝะฐัะผะพััะตัััั{}, // ะฝะฐัะผะพััะตัััั ะฝะฐ ะฑะตะทะพะฑัะฐะทะธั
rus_verbs:ะฝะฐัััะพะธัั{}, // ะฝะฐัััะพะธัั ะฝะฐ ะบะพัะพัะบะธะต ะฒะพะปะฝั
rus_verbs:ัะผะตะฝััะธัััั{}, // ัะผะตะฝััะธัััั ะฝะฐ ะฟะฐัั ัะฐะฝัะธะผะตััะพะฒ
rus_verbs:ะฟะพะผะตะฝััััั{}, // ะฟะพะผะตะฝััััั ะฝะฐ ะดััะณัั ะบะฝะธะถะบั
rus_verbs:ัะฐัะบะพะปะพัััั{}, // ัะฐัะบะพะปะพัััั ะฝะฐ ัะฐััะธ
rus_verbs:ัะฐะทะปะธัััั{}, // ัะฐะทะปะธัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ัััะฒะฐัััั{}, // ัััะฒะฐัััั ะฝะฐ ะถะตะฝั
rus_verbs:ะพััะดะธัั{}, // ะพััะดะธัั ะฝะฐ ะฟะพะถะธะทะฝะตะฝะฝะพะต ะทะฐะบะปััะตะฝะธะต
rus_verbs:ะฟะตัะตะดะฒะธะฝััั{}, // ะฟะตัะตะดะฒะธะฝััั ะฝะฐ ะฟะตัะฒะพะต ะผะตััะพ
rus_verbs:ะดะพะฟััะบะฐัััั{}, // ะดะพะฟััะบะฐัััั ะฝะฐ ะฟะพะปะธะณะพะฝ
rus_verbs:ะทะฐะดะฒะธะฝััั{}, // ะทะฐะดะฒะธะฝััั ะฝะฐ ะฟะพะปะบั
rus_verbs:ะฟะพะฒะปะธััั{}, // ะฟะพะฒะปะธััั ะฝะฐ ะพัะตะฝะบั
rus_verbs:ะพัะฑะฐะฒะปััั{}, // ะพัะฑะฐะฒะปััั ะฝะฐ ะพัะผะพัั
rus_verbs:ัะฑัะฐััะฒะฐัั{}, // ัะฑัะฐััะฒะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฝะฐะบะธะฝััััั{}, // ะฝะฐะบะธะฝััััั ะฝะฐ ัะปััะฐะนะฝัั
ะฟัะพั
ะพะถะธั
rus_verbs:ะฟัะพะปะธัั{}, // ะฟัะพะปะธัั ะฝะฐ ะบะพะถั ััะบะธ
rus_verbs:ะทะฐัะฐัะธัั{}, // ะทะฐัะฐัะธัั ะฝะฐ ัะตะฝะพะฒะฐะป
rus_verbs:ะฟะตัะตะฑะตะถะฐัั{}, // ะฟะตัะตะฑะตะถะฐัั ะฝะฐ ััะพัะพะฝั ะฟัะพัะธะฒะฝะธะบะฐ
rus_verbs:ะฝะฐะปะธะฒะฐัั{}, // ะฝะฐะปะธะฒะฐัั ะฝะฐ ัะบะฐัะตััั
rus_verbs:ะฟัะพะปะตะทัั{}, // ะฟัะพะปะตะทัั ะฝะฐ ััะตะฝั
rus_verbs:ะพัะบะปะฐะดัะฒะฐัั{}, // ะพัะบะปะฐะดัะฒะฐัั ะฝะฐ ัะตัะฝัะน ะดะตะฝั
rus_verbs:ัะฐัะฟะฐะดะฐัััั{}, // ัะฐัะฟะฐะดะฐัััั ะฝะฐ ะฝะตะฑะพะปััะธะต ััะฐะณะผะตะฝัั
rus_verbs:ะฟะตัะตัะธัะปะธัั{}, // ะฟะตัะตัะธัะปะธัั ะฝะฐ ััะตั
rus_verbs:ะทะฐะบะฐัะฐัััั{}, // ะทะฐะบะฐัะฐัััั ะฝะฐ ะฒะตัั
ะฝะธะน ััะพะฒะตะฝั
rus_verbs:ะฝะฐะบัะตะฝะธัััั{}, // ะฝะฐะบัะตะฝะธัััั ะฝะฐ ะฟัะฐะฒัะน ะฑะพัั
rus_verbs:ะฟะพะดะฒะธะฝััััั{}, // ะฟะพะดะฒะธะฝััััั ะฝะฐ ะพะดะธะฝ ััะพะฒะตะฝั
rus_verbs:ัะฐะทะฝะตััะธ{}, // ัะฐะทะฝะตััะธ ะฝะฐ ะผะตะปะบะธะต ะบััะพัะบะธ
rus_verbs:ะทะฐะถะธัั{}, // ะทะฐะถะธัั ะฝะฐ ัะธัะพะบัั ะฝะพะณั
rus_verbs:ะพะณะปะพั
ะฝััั{}, // ะพะณะปะพั
ะฝััั ะฝะฐ ะฟัะฐะฒะพะต ัั
ะพ
rus_verbs:ะฟะพัะตัะพะฒะฐัั{}, // ะฟะพัะตัะพะฒะฐัั ะฝะฐ ะฑััะพะบัะฐัะธะทะผ
rus_verbs:ัะฒะพะดะธัั{}, // ัะฒะพะดะธัั ะฝะฐ ะพัะผะพัั
rus_verbs:ััะบะฐะบะฐัั{}, // ััะบะฐะบะฐัั ะฝะฐ ะทะฐะฑะตะณ
rus_verbs:ะฟะพัะฒะตัะธัั{}, // ะฟะพัะฒะตัะธัั ะฝะฐ ััะตะฝั
rus_verbs:ัะฐะทััะฒะฐัััั{}, // ัะฐะทััะฒะฐัััั ะฝะฐ ัะฐััะธ
rus_verbs:ะฟะพะฑัะพัะฐัั{}, // ะฟะพะฑัะพัะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะบะฐัะฐะฑะบะฐัััั{}, // ะบะฐัะฐะฑะบะฐัััั ะฝะฐ ัะบะฐะปั
rus_verbs:ะฝะฐั
ะปัะฝััั{}, // ะฝะฐั
ะปัะฝััั ะฝะฐ ะบะพะณะพ-ัะพ
rus_verbs:ัะฐะทะปะตัะฐัััั{}, // ัะฐะทะปะตัะฐัััั ะฝะฐ ะผะตะปะบะธะต ะพัะบะพะปะพัะบะธ
rus_verbs:ััะตะฐะณะธัะพะฒะฐัั{}, // ััะตะฐะณะธัะพะฒะฐัั ะฝะฐ ัะธะณะฝะฐะป
rus_verbs:ะฟัะตัะตะฝะดะพะฒะฐัั{}, // ะฟัะตัะตะฝะดะพะฒะฐัั ะฝะฐ ะฟัะธะท
rus_verbs:ะดัะฝััั{}, // ะดัะฝััั ะฝะฐ ะพะดัะฒะฐะฝัะธะบ
rus_verbs:ะฟะตัะตะฒะพะดะธัััั{}, // ะฟะตัะตะฒะพะดะธัััั ะฝะฐ ะดััะณัั ัะฐะฑะพัั
rus_verbs:ะฟะตัะตะฒะตะทัะธ{}, // ะฟะตัะตะฒะตะทัะธ ะฝะฐ ะดััะณัั ะฟะปะพัะฐะดะบั
rus_verbs:ัะพะฟะฐัั{}, // ัะพะฟะฐัั ะฝะฐ ััะพะบ
rus_verbs:ะพัะฝะพัะธัั{}, // ะพัะฝะพัะธัั ะฝะฐ ัะบะปะฐะด
rus_verbs:ัะฑะธะฒะฐัั{}, // ัะฑะธะฒะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะบะปะฐะดัะฒะฐัั{}, // ัะบะปะฐะดัะฒะฐัั ะฝะฐ ัะฟะธะฝั
rus_verbs:ัะบะฐัะธัั{}, // ัะบะฐัะธัั ะฝะฐ ะพัะดัั
rus_verbs:ัะฑะธัะฐัั{}, // ัะฑะธัะฐัั ะฝะฐ ะฟะพะปะบั
rus_verbs:ะพะฟะฐััั{}, // ะพะฟะฐััั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะพะฝััั{}, // ัะพะฝััั ะฝะฐ ัะฝะตะณ
rus_verbs:ะฟัะปะธัััั{}, // ะฟัะปะธัััั ะฝะฐ ัะตะปะพ
rus_verbs:ะณะปะฐะทะตัั{}, // ะณะปะฐะทะตัั ะฝะฐ ัะตะปะพ
rus_verbs:ัะฝะธะถะฐัััั{}, // ัะฝะธะถะฐัััั ะฝะฐ ะฑะตะทะพะฟะฐัะฝัั ะฒััะพัั
rus_verbs:ะทะฐะฟััะณะฝััั{}, // ะทะฐะฟััะณะฝััั ะฝะฐ ะฟะปะฐััะพัะผั
rus_verbs:ัะฐะทะฑะธะฒะฐัััั{}, // ัะฐะทะฑะธะฒะฐัััั ะฝะฐ ะณะปะฐะฒั
rus_verbs:ัะณะพะดะธัััั{}, // ัะณะพะดะธัััั ะฝะฐ ัะฐัั
rus_verbs:ะฟะตัะตัะบะพัะธัั{}, // ะฟะตัะตัะบะพัะธัั ะฝะฐ ะดััะณัั ัััะฐะฝะธัั
rus_verbs:ะฝะฐัะตะปะธัััั{}, // ะฝะฐัะตะปะธัััั ะฝะฐ ะณะปะฐะฒะฝัั ะดะพะฑััั
rus_verbs:ะทะฐะตะทะถะฐัั{}, // ะทะฐะตะทะถะฐัั ะฝะฐ ะฑะพัะดัั
rus_verbs:ะทะฐะฑะธัะฐัััั{}, // ะทะฐะฑะธัะฐัััั ะฝะฐ ะบัััั
rus_verbs:ะฟัะพะพัะฐัั{}, // ะฟัะพะพัะฐัั ะฝะฐ ะฒัั ัะตะปะพ
rus_verbs:ัะฑะตะถะฐัััั{}, // ัะฑะตะถะฐัััั ะฝะฐ ััะผ
rus_verbs:ัะผะตะฝััั{}, // ัะผะตะฝััั ะฝะฐ ั
ะปะตะฑ
rus_verbs:ะผะพัะฐัั{}, // ะผะพัะฐัั ะฝะฐ ัั
rus_verbs:ัะฐัะบะฐะปัะฒะฐัััั{}, // ัะฐัะบะฐะปัะฒะฐัััั ะฝะฐ ะดะฒะต ะฟะพะปะพะฒะธะฝะบะธ
rus_verbs:ะบะพัะธัััั{}, // ะบะพัะธัััั ะฝะฐ ัะตะถะธััััะฐ
rus_verbs:ะฟะปะตะฒะฐัั{}, // ะฟะปะตะฒะฐัั ะฝะฐ ะทะฐะบะพะฝั
rus_verbs:ัััะปะฐัััั{}, // ัััะปะฐัััั ะฝะฐ ะฐะฒัะพัะธัะตัะฝะพะต ะผะฝะตะฝะธะต
rus_verbs:ะฝะฐััะฐะฒะธัั{}, // ะฝะฐััะฐะฒะธัั ะฝะฐ ะฟััั ะธััะธะฝะฝัะน
rus_verbs:ะทะฐะฒัะฒะฐัั{}, // ะทะฐะฒัะฒะฐัั ะฝะฐ ะัะฝั
rus_verbs:ะพะฟะฐะทะดัะฒะฐัั{}, // ะพะฟะฐะทะดัะฒะฐัั ะฝะฐ ัะพะฒะตัะฐะฝะธะต
rus_verbs:ะทะฐะปัะฑะพะฒะฐัััั{}, // ะทะฐะปัะฑะพะฒะฐัััั ะฝะฐ ะฟะตะนะทะฐะถ
rus_verbs:ะฟะพะฒะตัะณะฝััั{}, // ะฟะพะฒะตัะณะฝััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฝะฐะดะฒะธะฝััั{}, // ะฝะฐะดะฒะธะฝััั ะฝะฐ ะปะพะฑ
rus_verbs:ััะตะบะฐัััั{}, // ััะตะบะฐัััั ะฝะฐ ะฟะปะพัะฐะดั
rus_verbs:ะพะฑะพะทะปะธัััั{}, // ะพะฑะพะทะปะธัััั ะฝะฐ ััะตะฝะตัะฐ
rus_verbs:ะพัััะฝััั{}, // ะพัััะฝััั ะฝะฐ ัะตะฑั
rus_verbs:ะธัััะฐัะธัั{}, // ะธัััะฐัะธัั ะฝะฐ ะดะตัะตะฒัั
ัะปัั
rus_verbs:ะฒััะฒััะฝััั{}, // ะฒััะฒััะฝััั ะฝะฐ ัะปะธัั
rus_verbs:ะทะฐัะพะปะบะฐัั{}, // ะทะฐัะพะปะบะฐัั ะฝะฐ ะฒะตัั
ะฝัั ะฟะพะปะบั
rus_verbs:ะทะฐัะบะพัะธัั{}, // ะทะฐัะบะพัะธัั ะฝะฐ ะพะณะพะฝะตะบ
rus_verbs:ะฟัะพัะธัััั{}, // ะฟัะพัะธัััั ะฝะฐ ัะปะธัั
rus_verbs:ะฝะฐััะบะฐัััั{}, // ะฝะฐััะบะฐัััั ะฝะฐ ะฑะพััะตะฒะธะบ
rus_verbs:ะพะฑัััะธะฒะฐัััั{}, // ะพะฑัััะธะฒะฐัััั ะฝะฐ ะผะธัะธะฝะณัััะธั
rus_verbs:ะฟะตัะตะฟะธัะฐัั{}, // ะฟะตัะตะฟะธัะฐัั ะฝะฐ ัะธััะพะฒะธะบ
rus_verbs:ะฟะตัะตะฝะพัะธัััั{}, // ะฟะตัะตะฝะพัะธัััั ะฝะฐ ะดััะณะพะต ััััะพะนััะฒะพ
rus_verbs:ะฝะฐะฟัะพัะธัััั{}, // ะฝะฐะฟัะพัะธัััั ะฝะฐ ะพะฑะธะดะฝัะน ะพัะฒะตั
rus_verbs:ะฝะฐััะณะธะฒะฐัั{}, // ะฝะฐััะณะธะฒะฐัั ะฝะฐ ะฝะพะณะธ
rus_verbs:ะบะธะดะฐัััั{}, // ะบะธะดะฐัััั ะฝะฐ ะฟัะพั
ะพะถะธั
rus_verbs:ะพัะบะปะธะบะฐัััั{}, // ะพัะบะปะธะบะฐัััั ะฝะฐ ะฟัะธะทัะฒ
rus_verbs:ะฟะพัะฟะตะฒะฐัั{}, // ะฟะพัะฟะตะฒะฐัั ะฝะฐ ะฑะฐะปะตั
rus_verbs:ะพะฑัะฐัะธัััั{}, // ะพะฑัะฐัะธัััั ะฝะฐ ะบะฐัะตะดัั
rus_verbs:ะฟะพะปัะฑะพะฒะฐัััั{}, // ะฟะพะปัะฑะพะฒะฐัััั ะฝะฐ ะฑััั
rus_verbs:ัะฐัะฐัะธัััั{}, // ัะฐัะฐัะธัััั ะฝะฐ ะผัััะฐะฝะณะพะฒ
rus_verbs:ะฝะฐะฟะพัะพัััั{}, // ะฝะฐะฟะพัะพัััั ะฝะฐ ะบะพะปััะบะธ
rus_verbs:ัะฐะทะดะฐัั{}, // ัะฐะทะดะฐัั ะฝะฐ ััะบะธ
rus_verbs:ะดะธะฒะธัััั{}, // ะดะธะฒะธัััั ะฝะฐ ัะฐะฝัะพะฒัะธั
rus_verbs:ะฝะฐะทะฝะฐัะฐัั{}, // ะฝะฐะทะฝะฐัะฐัั ะฝะฐ ะพัะฒะตัััะฒะตะฝะฝะตะนัะธะน ะฟะพัั
rus_verbs:ะบะธะดะฐัั{}, // ะบะธะดะฐัั ะฝะฐ ะฑะฐะปะบะพะฝ
rus_verbs:ะฝะฐั
ะปะพะฑััะธัั{}, // ะฝะฐั
ะปะพะฑััะธัั ะฝะฐ ะฑะฐัะบั
rus_verbs:ัะฒะปะตะบะฐัั{}, // ัะฒะปะตะบะฐัั ะฝะฐ ะปัะณ
rus_verbs:ััะณะฝััััั{}, // ััะณะฝััััั ะฝะฐ ะถะธะฒะพัะธะฝั
rus_verbs:ะฟะตัะตัะตะปะธัััั{}, // ะฟะตัะตัะตะปะธัััั ะฝะฐ ั
ััะพั
rus_verbs:ัะฐะทััะฒะฐัั{}, // ัะฐะทััะฒะฐัั ะฝะฐ ัะฐััะธ
rus_verbs:ััะฐัะธัั{}, // ััะฐัะธัั ะฝะฐ ะดะตัะตะฒะพ
rus_verbs:ะฝะฐััะฐะฒะปััั{}, // ะฝะฐััะฐะฒะปััั ะฝะฐ ะฟััั
rus_verbs:ัะพะฑะปะฐะทะฝะธัั{}, // ัะพะฑะปะฐะทะฝะธัั ะฝะฐ ะพะฑะผะตะฝ
rus_verbs:ะฝะฐะบะปะฐะดัะฒะฐัั{}, // ะฝะฐะบะปะฐะดัะฒะฐัั ะฝะฐ ัะฐะฝั
rus_verbs:ะฝะฐะฑัะตััะธ{}, // ะฝะฐะฑัะตััะธ ะฝะฐ ะณัะธะฑะฝัั ะฟะพะปัะฝั
rus_verbs:ะฝะฐะฒะตะดัะฒะฐัััั{}, // ะฝะฐะฒะตะดัะฒะฐัััั ะฝะฐ ะฟัะตะถะฝัั ัะฐะฑะพัั
rus_verbs:ะฟะพะณัะปััั{}, // ะฟะพะณัะปััั ะฝะฐ ััะถะธะต ะดะตะฝัะณะธ
rus_verbs:ัะบะปะพะฝััััั{}, // ัะบะปะพะฝััััั ะฝะฐ ะดะฒะฐ ะณัะฐะดััะฐ ะฒะปะตะฒะพ
rus_verbs:ัะปะตะทะฐัั{}, // ัะปะตะทะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะบะปะตะฒะฐัั{}, // ะบะปะตะฒะฐัั ะฝะฐ ะผะพััะปั
// rus_verbs:ะฝะฐะทะฝะฐัะฐัััั{}, // ะฝะฐะทะฝะฐัะฐัััั ะฝะฐ ะฟะพัั
rus_verbs:ะฝะฐะฟัะปะธัั{}, // ะฝะฐะฟัะปะธัั ะฝะฐ ะณะพะปะพะฒั
rus_verbs:ะฝะฐััะฝััััั{}, // ะฝะฐััะฝััััั ะฝะฐ ัะฐะผะบั
rus_verbs:ัะฐะทะณะฝะตะฒะฐัััั{}, // ัะฐะทะณะฝะตะฒะฐัััั ะฝะฐ ะฟัะธะดะฒะพัะฝัั
rus_verbs:ัะผะธะณัะธัะพะฒะฐัั{}, // ัะผะธะณัะธัะพะฒะฐัั ะฝะฐ ะะธะฟั
rus_verbs:ะฝะฐะบะฐัะธัั{}, // ะฝะฐะบะฐัะธัั ะฝะฐ ะพัะฝะพะฒั
rus_verbs:ะฟัะธะณะฝะฐัั{}, // ะฟัะธะณะฝะฐัั ะฝะฐ ะฟะฐััะฑะธัะต
rus_verbs:ะพะฑัะตัั{}, // ะพะฑัะตัั ะฝะฐ ะผััะตะฝะธั
rus_verbs:ัะพะบัะฐัะฐัััั{}, // ัะพะบัะฐัะฐัััั ะฝะฐ ัะตัะฒะตััั
rus_verbs:ะพััะตัะฝะธัั{}, // ะพััะตัะฝะธัั ะฝะฐ ะฟัะธััะฐะฝั
rus_verbs:ะฟะพะดะฑะธัั{}, // ะฟะพะดะฑะธัั ะฝะฐ ะฐัะตัั
rus_verbs:ะทะฐะผะฐะฝะธัั{}, // ะทะฐะผะฐะฝะธัั ะฝะฐ ะดะตัะตะฒะพ
ะธะฝัะธะฝะธัะธะฒ:ะฟะพะฟะธัะฐัั{ aux stress="ะฟะพะฟ^ะธัะฐัั" }, ะณะปะฐะณะพะป:ะฟะพะฟะธัะฐัั{ aux stress="ะฟะพะฟ^ะธัะฐัั" }, // ะฟะพะฟะธัะฐัั ะฝะฐ ะบัััะธะบ
// ะดะตะตะฟัะธัะฐััะธะต:ะฟะพะฟะธัะฐะฒ{ aux stress="ะฟะพะฟ^ะธัะฐัั" },
rus_verbs:ะฟะพัั
ะพะดะธัั{}, // ะฟะพัั
ะพะดะธัั ะฝะฐ ะฟะตััะพะฝ
rus_verbs:ะฝะฐะปะตัั{}, // ะฝะฐะปะตัั ะฝะฐ ะผัััะพ
rus_verbs:ะพัะฑะธัะฐัั{}, // ะพัะฑะธัะฐัั ะฝะฐ ัะปะพั
rus_verbs:ะฝะฐัะตะฟััะฒะฐัั{}, // ะฝะฐัะตะฟััะฒะฐัั ะฝะฐ ัั
ะพ
rus_verbs:ะพัะบะปะฐะดัะฒะฐัััั{}, // ะพัะบะปะฐะดัะฒะฐัััั ะฝะฐ ะฑัะดััะตะต
rus_verbs:ะทะฐะปะฐััั{}, // ะทะฐะปะฐััั ะฝะฐ ะณัะฐะฑะธัะตะปั
rus_verbs:ะฝะฐัััะพะธัััั{}, // ะฝะฐัััะพะธัััั ะฝะฐ ะฟัะธะตะผ
rus_verbs:ัะฐะทะฑะธะฒะฐัั{}, // ัะฐะทะฑะธะฒะฐัั ะฝะฐ ะบััะบะธ
rus_verbs:ะฟัะพะปะธัััั{}, // ะฟัะพะปะธัััั ะฝะฐ ะฟะพัะฒั
rus_verbs:ัะตัะพะฒะฐัั{}, // ัะตัะพะฒะฐัั ะฝะฐ ะพะฑัะตะบัะธะฒะฝัะต ัััะดะฝะพััะธ
rus_verbs:ะฟะพะดะฒะตะทัะธ{}, // ะฟะพะดะฒะตะทัะธ ะฝะฐ ะผะธัะธะฝะณ
rus_verbs:ะฟัะธะฟะตัะตัััั{}, // ะฟัะธะฟะตัะตัััั ะฝะฐ ะฟัะฐะทะดะฝะธะบ
rus_verbs:ะฟะพะดัะฐะปะบะธะฒะฐัั{}, // ะฟะพะดัะฐะปะบะธะฒะฐัั ะฝะฐ ะฟััะถะพะบ
rus_verbs:ะฟัะพััะฒะฐัััั{}, // ะฟัะพััะฒะฐัััั ะฝะฐ ััะตะฝั
rus_verbs:ัะฝะธะถะฐัั{}, // ัะฝะธะถะฐัั ะฝะฐ ะฝะตัะบะพะปัะบะพ ะฟัะพัะตะฝัะพะฒ
rus_verbs:ะฝะฐัะตะปะธัั{}, // ะฝะฐัะตะปะธัั ะฝะฐ ัะฐะฝะบ
rus_verbs:ัะฐัะบะพะปะพัั{}, // ัะฐัะบะพะปะพัั ะฝะฐ ะดะฒะฐ ะบััะบะฐ
rus_verbs:ัะฒะพะทะธัั{}, // ัะฒะพะทะธัั ะฝะฐ ะพะฑะบะฐัะบั
rus_verbs:ะพัะตะดะฐัั{}, // ะพัะตะดะฐัั ะฝะฐ ะดะฝะพ
rus_verbs:ััะตะดะฐัั{}, // ััะตะดะฐัั ะฝะฐ ัะถะธะฝ
rus_verbs:ะฝะฐะฒะปะตัั{}, // ะฝะฐะฒะปะตัั ะฝะฐ ัะตะฑั
rus_verbs:ัะฐะฒะฝััััั{}, // ัะฐะฒะฝััััั ะฝะฐ ะปัััะธั
rus_verbs:ัะพัะธะตะฝัะธัะพะฒะฐัััั{}, // ัะพัะธะตะฝัะธัะพะฒะฐัััั ะฝะฐ ะผะตััะฝะพััะธ
rus_verbs:ัะฝะธะทะธัั{}, // ัะฝะธะทะธัั ะฝะฐ ะฝะตัะบะพะปัะบะพ ะฟัะพัะตะฝัะพะฒ
rus_verbs:ะฟะตัะตะฝะตััะธัั{}, // ะฟะตัะตะฝะตััะธัั ะฝะฐ ะผะฝะพะณะพ ะปะตั ะฝะฐะทะฐะด
rus_verbs:ะทะฐะฒะตะทัะธ{}, // ะทะฐะฒะตะทัะธ ะฝะฐ ัะบะปะฐะด
rus_verbs:ะฟัะพะปะพะถะธัั{}, // ะฟัะพะปะพะถะธัั ะฝะฐ ะณะพัั
rus_verbs:ะฟะพะฝะฐะดะตััััั{}, // ะฟะพะฝะฐะดะตััััั ะฝะฐ ัะดะฐัั
rus_verbs:ะทะฐัััะฟะธัั{}, // ะทะฐัััะฟะธัั ะฝะฐ ะฒะฐั
ัั
rus_verbs:ะทะฐัะตะผะตะฝะธัั{}, // ะทะฐัะตะผะตะฝะธัั ะฝะฐ ะฒัั
ะพะด
rus_verbs:ะทะฐะฟะธัะฐัั{}, // ะทะฐะฟะธัะฐัั ะฝะฐ ะบะปัั
rus_verbs:ัะบะฐััะฒะฐัััั{}, // ัะบะฐััะฒะฐัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะดัะพะฑะธัั{}, // ะดัะพะฑะธัั ะฝะฐ ัะฐััะธ
rus_verbs:ัะฐะทะฒะฐะปะธะฒะฐัััั{}, // ัะฐะทะฒะฐะปะธะฒะฐัััั ะฝะฐ ะบััะพัะบะธ
rus_verbs:ะทะฐะฒะพะทะธัััั{}, // ะทะฐะฒะพะทะธัััั ะฝะฐ ัะบะปะฐะด
rus_verbs:ะฝะฐะฝะธะผะฐัั{}, // ะฝะฐะฝะธะผะฐัั ะฝะฐ ะดะฝะตะฒะฝัั ัะฐะฑะพัั
rus_verbs:ะฟะพัะฟะตัั{}, // ะฟะพัะฟะตัั ะฝะฐ ะบะพะฝัะตัั
rus_verbs:ะฟัะพะผะตะฝััั{}, // ะฟัะพะผะตะฝััั ะฝะฐ ัััะพััั
rus_verbs:ะฟะตัะตะฟัะฐะฒะธัั{}, // ะฟะตัะตะฟัะฐะฒะธัั ะฝะฐ ัะตะฒะตั
rus_verbs:ะฝะฐะปะตัะฐัั{}, // ะฝะฐะปะตัะฐัั ะฝะฐ ัะธะปะพะฒะพะต ะฟะพะปะต
rus_verbs:ะทะฐัะฒะพัะธัั{}, // ะทะฐัะฒะพัะธัั ะฝะฐ ะทะฐะผะพะบ
rus_verbs:ะฟะพะดะพะณะฝะฐัั{}, // ะฟะพะดะพะณะฝะฐัั ะฝะฐ ะฟัะธััะฐะฝั
rus_verbs:ะฝะฐะตั
ะฐัั{}, // ะฝะฐะตั
ะฐัั ะฝะฐ ะบะฐะผะตะฝั
rus_verbs:ัะฐัะฟะตะฒะฐัั{}, // ัะฐัะฟะตะฒะฐัั ะฝะฐ ัะฐะทะฝัะต ะณะพะปะพัะฐ
rus_verbs:ัะฐะทะฝะพัะธัั{}, // ัะฐะทะฝะพัะธัั ะฝะฐ ะบะปะพัะบะธ
rus_verbs:ะฟัะตัะฒะตะปะธัะธะฒะฐัั{}, // ะฟัะตัะฒะตะปะธัะธะฒะฐัั ะฝะฐ ะผะฝะพะณะพ ะบะธะปะพะณัะฐะผะผะพะฒ
rus_verbs:ั
ัะพะผะฐัั{}, // ั
ัะพะผะฐัั ะฝะฐ ะพะดะฝั ะฝะพะณั
rus_verbs:ัะตะปะตะณัะฐัะธัะพะฒะฐัั{}, // ัะตะปะตะณัะฐัะธัะพะฒะฐัั ะฝะฐ ะฑะฐะทั
rus_verbs:ะฟะพัะตะทะฐัั{}, // ะฟะพัะตะทะฐัั ะฝะฐ ะปะพัะบััั
rus_verbs:ะฟะพัะฒะฐัััั{}, // ะฟะพัะฒะฐัััั ะฝะฐ ัะฐััะธ
rus_verbs:ะทะฐะณะพะฝััั{}, // ะทะฐะณะพะฝััั ะฝะฐ ะดะตัะตะฒะพ
rus_verbs:ะพัะฑัะฒะฐัั{}, // ะพัะฑัะฒะฐัั ะฝะฐ ะผะตััะพ ัะปัะถะฑั
rus_verbs:ััะฐะถะธะฒะฐัััั{}, // ััะฐะถะธะฒะฐัััั ะฝะฐ ััะพะฝ
rus_verbs:ะฝะฐะบะพะฟะธัั{}, // ะฝะฐะบะพะฟะธัั ะฝะฐ ะบะฒะฐััะธัั
rus_verbs:ะทััะบะฝััั{}, // ะทััะบะฝััั ะฝะฐ ะฒะธะทะธัะตัะฐ
rus_verbs:ะบะพะฟะธัั{}, // ะบะพะฟะธัั ะฝะฐ ะผะฐัะธะฝั
rus_verbs:ะฟะพะผะตัะฐัั{}, // ะฟะพะผะตัะฐัั ะฝะฐ ะฒะตัั
ะฝัั ะณัะฐะฝั
rus_verbs:ัะฟะพะปะทะฐัั{}, // ัะฟะพะปะทะฐัั ะฝะฐ ัะฝะตะณ
rus_verbs:ะฟะพะฟัะพัะธัััั{}, // ะฟะพะฟัะพัะธัััั ะฝะฐ ัะปะธัั
rus_verbs:ะฟะตัะตัะฐัะธัั{}, // ะฟะตัะตัะฐัะธัั ะฝะฐ ัะตัะดะฐะบ
rus_verbs:ัะฐััะฐัะธัั{}, // ัะฐััะฐัะธัั ะฝะฐ ััะฒะตะฝะธัั
rus_verbs:ะฝะธัะฟะฐะดะฐัั{}, // ะฝะธัะฟะฐะดะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ััะพัะพะณัะฐัะธัะพะฒะฐัั{}, // ััะพัะพะณัะฐัะธัะพะฒะฐัั ะฝะฐ ะฟะฐะผััั
rus_verbs:ะฝะฐะณะพะฝััั{}, // ะฝะฐะณะพะฝััั ะฝะฐ ะบะพะฝะบััะตะฝัะพะฒ ัััะฐั
rus_verbs:ะฟะพะบััะฐัััั{}, // ะฟะพะบััะฐัััั ะฝะฐ ะฟะพะฝัะธัะธะบะฐ
rus_verbs:ะฟะพะบััะธัััั{},
rus_verbs:ะฝะฐะฝััััั{}, // ะฝะฐะฝััััั ะฝะฐ ัะปัะถะฑั
rus_verbs:ะฟัะพัะฐัะธะฒะฐัััั{}, // ะฟัะพัะฐัะธะฒะฐัััั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััั
rus_verbs:ะฟััะบะฐัััั{}, // ะฟััะบะฐัััั ะฝะฐ ะฒะตัะตั
rus_verbs:ะพัะฒะฐะถะธะฒะฐัััั{}, // ะพัะฒะฐะถะธะฒะฐัััั ะฝะฐ ะฟััะถะพะบ
rus_verbs:ะดะพัะฐะดะพะฒะฐัั{}, // ะดะพัะฐะดะพะฒะฐัั ะฝะฐ ะพะฑัะตะบัะธะฒะฝัะต ัััะดะฝะพััะธ
rus_verbs:ัะฝะตััะธัั{}, // ัะฝะตััะธัั ะฝะฐ ะฝะตะฑะพ
rus_verbs:ัั
ัะดัะฐัััั{}, // ัั
ัะดัะฐัััั ะฝะฐ ะฝะตัะบะพะปัะบะพ ะฟัะพัะตะฝัะพะฒ
rus_verbs:ะฝะฐัะฐะดะธัั{}, // ะฝะฐัะฐะดะธัั ะฝะฐ ะบะพะฟัั
rus_verbs:ะฝะฐะณััะฝััั{}, // ะฝะฐะณััะฝััั ะฝะฐ ะฟัะฐะทะดะฝะธะบ
rus_verbs:ะทะฐัะฒััะฝััั{}, // ะทะฐัะฒััะฝััั ะฝะฐ ะฟะพะปะบั
rus_verbs:ะณัะตัะธัั{}, // ะณัะตัะธัั ะฝะฐ ะฟะพััะพัะปััะตะฒ
rus_verbs:ะฟัะพัะพัะธัััั{}, // ะฟัะพัะพัะธัััั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััั
rus_verbs:ะฝะฐะดะพัะผะธัั{}, // ะฝะฐะดะพัะผะธัั ะฝะฐ ะณะปัะฟะพััั
rus_verbs:ะฝะฐะผะพัะฐัั{}, // ะฝะฐะผะพัะฐัั ะฝะฐ ัะฟะธะฝะดะตะปั
rus_verbs:ะทะฐะผะบะฝััั{}, // ะทะฐะผะบะฝััั ะฝะฐ ะบะพัะฟัั
rus_verbs:ััะบะฝััั{}, // ััะบะฝััั ะฝะฐ ะดะตัะตะน
rus_verbs:ะฟะตัะตะฒะพัะฐัะธะฒะฐัััั{}, // ะฟะตัะตะฒะพัะฐัะธะฒะฐัััั ะฝะฐ ัะฟะธะฝั
rus_verbs:ัะพะฒะฐัััั{}, // ัะพะฒะฐัััั ะฝะฐ ะฟะปะพัะฐัั
rus_verbs:ะพัะปััะธัััั{}, // ะพัะปััะธัััั ะฝะฐ ะพะฑะตะด
rus_verbs:ะฟะตะฝััั{}, // ะฟะตะฝััั ะฝะฐ ัะตะฑั
rus_verbs:ะฝะฐัะตะทะฐัั{}, // ะฝะฐัะตะทะฐัั ะฝะฐ ะปะพะผัะธะบะธ
rus_verbs:ะฟะพััะฐะฒะปััั{}, // ะฟะพััะฐะฒะปััั ะฝะฐ ะะธะฟั
rus_verbs:ะทะฐะปะตะทะฐัั{}, // ะทะฐะปะตะทะฐัั ะฝะฐ ะฑะฐะปะบะพะฝ
rus_verbs:ะพัะปััะฐัััั{}, // ะพัะปััะฐัััั ะฝะฐ ะพะฑะตะด
rus_verbs:ัะฑะธะฒะฐัััั{}, // ัะฑะธะฒะฐัััั ะฝะฐ ัะฐะณ
rus_verbs:ัะฐัะฐัะธัั{}, // ัะฐัะฐัะธัั ะณะปะฐะทะฐ ะฝะฐ ะฒะพัะตะดัะตะณะพ
rus_verbs:ะฟัะพัะผัะณะฝััั{}, // ะฟัะพัะผัะณะฝััั ะฝะฐ ะบัั
ะฝั
rus_verbs:ะพะฟะตัะตะถะฐัั{}, // ะพะฟะตัะตะถะฐัั ะฝะฐ ะฟะฐัั ัะฐะฝัะธะผะตััะพะฒ
rus_verbs:ะฟะตัะตััะฐะฒะธัั{}, // ะฟะตัะตััะฐะฒะธัั ะฝะฐ ััะพะป
rus_verbs:ัะฐะทะดะธัะฐัั{}, // ัะฐะทะดะธัะฐัั ะฝะฐ ัะฐััะธ
rus_verbs:ะทะฐัะฒะพัะธัััั{}, // ะทะฐัะฒะพัะธัััั ะฝะฐ ะทะฐัะพะฒั
rus_verbs:ะผะฐัะตัะธัััั{}, // ะผะฐัะตัะธัััั ะฝะฐ ะบะพะณะพ-ัะพ
rus_verbs:ะฝะฐัะบะพัะธัั{}, // ะฝะฐัะบะพัะธัั ะฝะฐ ัะธั
rus_verbs:ะฝะฐะฑะธัะฐัััั{}, // ะฝะฐะฑะธัะฐัััั ะฝะฐ ะฑะพัั
rus_verbs:ะฟะพะบัะธะบะธะฒะฐัั{}, // ะฟะพะบัะธะบะธะฒะฐัั ะฝะฐ ะฟะพะผะพัะฝะธะบะพะฒ
rus_verbs:ะทะฐะผะตะฝััััั{}, // ะทะฐะผะตะฝััััั ะฝะฐ ะฑะพะปะตะต ะฝะพะฒัะน
rus_verbs:ะฟะพะดัะฐะดะธัั{}, // ะฟะพะดัะฐะดะธัั ะฝะฐ ะฒะตัั
ะฝัั ะฟะพะปะบั
rus_verbs:ะฟัะพะบะพะฒัะปััั{}, // ะฟัะพะบะพะฒัะปััั ะฝะฐ ะบัั
ะฝั
rus_verbs:ะฟัะธะบะฐัะธัั{}, // ะฟัะธะบะฐัะธัั ะฝะฐ ััะฐัั
rus_verbs:ะทะฐะปะตัะตัั{}, // ะทะฐะปะตัะตัั ะฝะฐ ััะถัั ัะตััะธัะพัะธั
rus_verbs:ะทะฐะณััะทะธัั{}, // ะทะฐะณััะทะธัั ะฝะฐ ะบะพะฝะฒะตะนะตั
rus_verbs:ัะฟะปัะฒะฐัั{}, // ัะฟะปัะฒะฐัั ะฝะฐ ะผะฐัะตัะธะบ
rus_verbs:ะพะฟะพะทะพัะธัั{}, // ะพะฟะพะทะพัะธัั ะฝะฐ ะฒัั ะดะตัะตะฒะฝั
rus_verbs:ะฟัะพะฒะพัะธัะพะฒะฐัั{}, // ะฟัะพะฒะพัะธัะพะฒะฐัั ะฝะฐ ะพัะฒะตัะฝัั ะฐะณัะตััะธั
rus_verbs:ะทะฐะฑะธะฒะฐัั{}, // ะทะฐะฑะธะฒะฐัั ะฝะฐ ััะตะฑั
rus_verbs:ะฝะฐะฑะตะณะฐัั{}, // ะฝะฐะฑะตะณะฐัั ะฝะฐ ะฟัะธะฑัะตะถะฝัะต ะดะตัะตะฒะฝะธ
rus_verbs:ะทะฐะฟะธัะฐัััั{}, // ะทะฐะฟะธัะฐัััั ะฝะฐ ะบะปัั
rus_verbs:ัะพัะพะณัะฐัะธัะพะฒะฐัั{}, // ัะพัะพะณัะฐัะธัะพะฒะฐัั ะฝะฐ ะผัะปัะฝะธัั
rus_verbs:ะฟะพะดัะผะฐัั{}, // ะฟะพะดัะผะฐัั ะฝะฐ ะฝะตะดะพััะณะฐะตะผัั ะฒััะพัั
rus_verbs:ััะตะทะถะฐัััั{}, // ััะตะทะถะฐัััั ะฝะฐ ัะธะผะฟะพะทะธัะผ
rus_verbs:ะพัะฒะปะตะบะฐัััั{}, // ะพัะฒะปะตะบะฐัััั ะฝะฐ ะธะณัั
rus_verbs:ะฟัะพะปะธะฒะฐัั{}, // ะฟัะพะปะธะฒะฐัั ะฝะฐ ะฑััะบะธ
rus_verbs:ัะฟะธะบะธัะพะฒะฐัั{}, // ัะฟะธะบะธัะพะฒะฐัั ะฝะฐ ะทะฐะทะตะฒะฐะฒัะตะณะพัั ะทะฐะนัะฐ
rus_verbs:ัะฟะพะปะทัะธ{}, // ัะฟะพะปะทัะธ ะฝะฐ ะฒะตััะธะฝั ั
ะพะปะผะฐ
rus_verbs:ะฟะตัะตะผะตััะธัั{}, // ะฟะตัะตะผะตััะธัั ะฝะฐ ะฒัะพััั ะฟะฐะปัะฑั
rus_verbs:ะฟัะตะฒััะธัั{}, // ะฟัะตะฒััะธัั ะฝะฐ ะฝะตัะบะพะปัะบะพ ะผะตััะพะฒ
rus_verbs:ะฟะตัะตะดะฒะธะฝััััั{}, // ะฟะตัะตะดะฒะธะฝััััั ะฝะฐ ัะพัะตะดะฝัั ะบะปะตัะบั
rus_verbs:ัะฟัะพะฒะพัะธัะพะฒะฐัั{}, // ัะฟัะพะฒะพัะธัะพะฒะฐัั ะฝะฐ ะฑัะพัะพะบ
rus_verbs:ัะผะตััะธัััั{}, // ัะผะตััะธัััั ะฝะฐ ัะพัะตะดะฝัั ะบะปะตัะบั
rus_verbs:ะทะฐะณะพัะพะฒะธัั{}, // ะทะฐะณะพัะพะฒะธัั ะฝะฐ ะทะธะผั
rus_verbs:ะฟะปะตะฒะฐัััั{}, // ะฟะปะตะฒะฐัััั ะฝะฐ ะฟะพะป
rus_verbs:ะฟะตัะตัะตะปะธัั{}, // ะฟะตัะตัะตะปะธัั ะฝะฐ ัะตะฒะตั
rus_verbs:ะฝะฐะฟะธัะฐัั{}, // ะฝะฐะฟะธัะฐัั ะฝะฐ ะดะฒะตัั
rus_verbs:ะฟะตัะตะตะทะถะฐัั{}, // ะฟะตัะตะตะทะถะฐัั ะฝะฐ ะดััะณะพะน ััะฐะถ
rus_verbs:ะฟัะธะฟะพะดะฝะธะผะฐัั{}, // ะฟัะธะฟะพะดะฝะธะผะฐัั ะฝะฐ ะฝะตัะบะพะปัะบะพ ัะฐะฝัะธะผะตััะพะฒ
rus_verbs:ััะพะณะฐัััั{}, // ััะพะณะฐัััั ะฝะฐ ะบัะฐัะฝัะน ัะฒะตั
rus_verbs:ะฝะฐะดะฒะธะฝััััั{}, // ะฝะฐะดะฒะธะฝััััั ะฝะฐ ะณะปะฐะทะฐ
rus_verbs:ะทะฐัะผะพััะตัััั{}, // ะทะฐัะผะพััะตัััั ะฝะฐ ะบัะฟะฐะปัะฝะธะบะธ
rus_verbs:ัะฑััั{}, // ัะฑััั ะฝะฐ ััะพะฝั
rus_verbs:ะฟะตัะตะดะฒะธะณะฐัั{}, // ะฟะตัะตะดะฒะธะณะฐัั ะฝะฐ ะฒัะพัะพะน ััะพะฒะตะฝั
rus_verbs:ะพัะฒะพะทะธัั{}, // ะพัะฒะพะทะธัั ะฝะฐ ัะฒะฐะปะบั
rus_verbs:ะพะฑัะตะบะฐัั{}, // ะพะฑัะตะบะฐัั ะฝะฐ ะณะธะฑะตะปั
rus_verbs:ะทะฐะฟะธััะฒะฐัััั{}, // ะทะฐะฟะธััะฒะฐัััั ะฝะฐ ัะฐะฝัั
rus_verbs:ะฝะฐัััะฐะธะฒะฐัั{}, // ะฝะฐัััะฐะธะฒะฐัั ะฝะฐ ะดััะณะพะน ะดะธะฐะฟะฐะทะพะฝ
rus_verbs:ะฟะตัะตะฟะธััะฒะฐัั{}, // ะฟะตัะตะฟะธััะฒะฐัั ะฝะฐ ะดะธัะบ
rus_verbs:ะธะทัะฐัั
ะพะดะพะฒะฐัั{}, // ะธะทัะฐัั
ะพะดะพะฒะฐัั ะฝะฐ ะณะพะฝะบะธ
rus_verbs:ะพะฑะผะตะฝััั{}, // ะพะฑะผะตะฝััั ะฝะฐ ะฟะตััะฟะตะบัะธะฒะฝะพะณะพ ะธะณัะพะบะฐ
rus_verbs:ัััะฑะธัั{}, // ัััะฑะธัั ะฝะฐ ะฒัั ะพะบััะณั
rus_verbs:ะฝะฐะฑัะฐััะฒะฐัััั{}, // ะฝะฐะฑัะฐััะฒะฐัััั ะฝะฐ ะถะตััะฒั
rus_verbs:ัะธั
ะฐัั{}, // ัะธั
ะฐัั ะฝะฐ ะฟัะฐะฒะธะปะฐ
rus_verbs:ะฝะฐะฒะฐะปะธะฒะฐัััั{}, // ะฝะฐะฒะฐะปะธะฒะฐัััั ะฝะฐ ัััะฐะณ
rus_verbs:ัะฟะพะดะพะฑะธัััั{}, // ัะฟะพะดะพะฑะธัััั ะฝะฐ ะฟะพะฒัะพัะฝัะน ะฐะฝะฐะปะธะท
rus_verbs:ะฝะฐะผะฐะทะฐัั{}, // ะฝะฐะผะฐะทะฐัั ะฝะฐ ั
ะปะตะฑ
rus_verbs:ะฟัะพัะตะฐะณะธัะพะฒะฐัั{}, // ะฟัะพัะตะฐะณะธัะพะฒะฐัั ะฝะฐ ะฒัะทะพะฒ
rus_verbs:ะทะฐัะธัะปะธัั{}, // ะทะฐัะธัะปะธัั ะฝะฐ ัะฐะบัะปััะตั
rus_verbs:ะฝะฐะฒะตะดะฐัััั{}, // ะฝะฐะฒะตะดะฐัััั ะฝะฐ ัะบะปะฐะด
rus_verbs:ะพัะบะธะดัะฒะฐัััั{}, // ะพัะบะธะดัะฒะฐัััั ะฝะฐ ัะฟะธะฝะบั ะบัะตัะปะฐ
rus_verbs:ะทะฐั
ัะพะผะฐัั{}, // ะทะฐั
ัะพะผะฐัั ะฝะฐ ะปะตะฒัั ะฝะพะณั
rus_verbs:ะฟะตัะตะบะพัะตะฒะฐัั{}, // ะฟะตัะตะบะพัะตะฒะฐัั ะฝะฐ ะดััะณะพะน ะฑะตัะตะณ
rus_verbs:ะฝะฐะบะฐััะฒะฐัััั{}, // ะฝะฐะบะฐััะฒะฐัััั ะฝะฐ ะฟะตััะฐะฝัะน ะฑะตัะตะณ
rus_verbs:ะฟัะธะพััะฐะฝะพะฒะธัั{}, // ะฟัะธะพััะฐะฝะพะฒะธัั ะฝะฐ ะฝะตะบะพัะพัะพะต ะฒัะตะผั
rus_verbs:ะทะฐะฟัััะฐัั{}, // ะทะฐะฟัััะฐัั ะฝะฐ ะฒะตัั
ะฝัั ะฟะพะปะพัะบั
rus_verbs:ะฟัะธั
ัะฐะผัะฒะฐัั{}, // ะฟัะธั
ัะฐะผัะฒะฐัั ะฝะฐ ะฟัะฐะฒัั ะฝะพะณั
rus_verbs:ัะฟะพัั
ะฝััั{}, // ัะฟะพัั
ะฝััั ะฝะฐ ัะฒะพะฑะพะดั
rus_verbs:ัะฐัััะตะณะธะฒะฐัั{}, // ัะฐัััะตะณะธะฒะฐัั ะฝะฐ ะฟะฐะปััะพ
rus_verbs:ะฝะฐะฟัััะธัััั{}, // ะฝะฐะฟัััะธัััั ะฝะฐ ะฑัะพะดัะณั
rus_verbs:ะฝะฐะบะฐััะฒะฐัั{}, // ะฝะฐะบะฐััะฒะฐัั ะฝะฐ ะพัะธะณะธะฝะฐะป
rus_verbs:ะฝะฐะตะทะถะฐัั{}, // ะฝะฐะตะทะถะฐัั ะฝะฐ ะฟัะพััะพัะธะปั
rus_verbs:ััะฒะบะฝััั{}, // ััะฒะบะฝััั ะฝะฐ ะฟะพะดะพัะตะดัะตะณะพ ัะตะปะพะฒะตะบะฐ
rus_verbs:ะพัััะดะธัั{}, // ะพัััะดะธัั ะฝะฐ ะฟะพัะธะฝะบั
rus_verbs:ะฟะพะปะพะถะธัััั{}, // ะฟะพะปะพะถะธัััั ะฝะฐ ะณะปะฐะฒะฐัั
rus_verbs:ะพะฟัะพะบะธะดัะฒะฐัั{}, // ะพะฟัะพะบะธะดัะฒะฐัั ะฝะฐ ะณะพะปะพะฒั
rus_verbs:ะฟะพัะพัะฐะฟะปะธะฒะฐัััั{}, // ะฟะพัะพัะฐะฟะปะธะฒะฐัััั ะฝะฐ ัะตะนั
rus_verbs:ะฝะฐะปะฐะณะฐัั{}, // ะฝะฐะปะฐะณะฐัั ะฝะฐ ะทะฐะตะผัะธะบะฐ
rus_verbs:ัะบะพะฟะธัะพะฒะฐัั{}, // ัะบะพะฟะธัะพะฒะฐัั ะฝะฐ ะดะธัะบ
rus_verbs:ะพะฟะฐะดะฐัั{}, // ะพะฟะฐะดะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะบัะฟะธัััั{}, // ะบัะฟะธัััั ะฝะฐ ะฟะพััะปั
rus_verbs:ะณะฝะตะฒะฐัััั{}, // ะณะฝะตะฒะฐัััั ะฝะฐ ัะปัะณ
rus_verbs:ัะปะตัะตัััั{}, // ัะปะตัะตัััั ะฝะฐ ัะฐะทะดะฐัั
rus_verbs:ัะฑะฐะฒะธัั{}, // ัะฑะฐะฒะธัั ะฝะฐ ะดะฒะฐ ััะพะฒะฝั
rus_verbs:ัะฟะธั
ะฝััั{}, // ัะฟะธั
ะฝััั ะฝะฐ ัะพัะตะดะฐ
rus_verbs:ะฝะฐะบัะธัะฐัั{}, // ะฝะฐะบัะธัะฐัั ะฝะฐ ัะตะฑะตะฝะบะฐ
rus_verbs:ะฟัะธะฑะตัะตัั{}, // ะฟัะธะฑะตัะตัั ะฝะฐ ัะถะธะฝ
rus_verbs:ะฟัะธะบะปะตะธัั{}, // ะฟัะธะบะปะตะธัั ะฝะฐ ะฒะตััะพะฒะพะต ััะตะบะปะพ
rus_verbs:ะพะฟะพะปัะธัััั{}, // ะพะฟะพะปัะธัััั ะฝะฐ ะฟะพััะตะดะฝะธะบะพะฒ
rus_verbs:ััะฐัะธัััั{}, // ััะฐัะธัััั ะฝะฐ ััะฒะตะฝะธัั
rus_verbs:ัะปะตัะฐัััั{}, // ัะปะตัะฐัััั ะฝะฐ ัะฒะตั
rus_verbs:ะดะพััะฐะฒะปััััั{}, // ะดะพััะฐะฒะปััััั ะฝะฐ ะฑะฐะทั
rus_verbs:ะฟะพะฟะปะตะฒะฐัั{}, // ะฟะพะฟะปะตะฒะฐัั ะฝะฐ ััะบะธ
rus_verbs:ะพะณััะทะฐัััั{}, // ะพะณััะทะฐัััั ะฝะฐ ะทะฐะผะตัะฐะฝะธะต
rus_verbs:ะฟะพะฟะตัะตัััั{}, // ะฟะพะฟะตัะตัััั ะฝะฐ ััะฝะพะบ
rus_verbs:ัะฐัััะณะธะฒะฐัััั{}, // ัะฐัััะณะธะฒะฐัััั ะฝะฐ ะฟะพะปั
rus_verbs:ะฟะพะฒะตัะณะฐัั{}, // ะฟะพะฒะตัะณะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะปะพะฒะธัััั{}, // ะปะพะฒะธัััั ะฝะฐ ะผะพััะปั
rus_verbs:ะฝะฐัะตะดะฐัั{}, // ะฝะฐัะตะดะฐัั ะฝะฐ ะพะฑะพัะพะฝัััะธั
ัั
rus_verbs:ัะฐะทะฒะฐะปะธัั{}, // ัะฐะทะฒะฐะปะธัั ะฝะฐ ะบะธัะฟะธัะธ
rus_verbs:ัะฐะทะปะพะผะธัั{}, // ัะฐะทะปะพะผะธัั ะฝะฐ ะฝะตัะบะพะปัะบะพ ัะฐััะตะน
rus_verbs:ะฟัะธะผะตัะธัั{}, // ะฟัะธะผะตัะธัั ะฝะฐ ัะตะฑั
rus_verbs:ะปะตะฟะธัััั{}, // ะปะตะฟะธัััั ะฝะฐ ััะตะฝั
rus_verbs:ัะบะพะฟะธัั{}, // ัะบะพะฟะธัั ะฝะฐ ััะฐัะพััั
rus_verbs:ะทะฐััะฐัะธัั{}, // ะทะฐััะฐัะธัั ะฝะฐ ะปะธะบะฒะธะดะฐัะธั ะฟะพัะปะตะดััะฒะธะน
rus_verbs:ะฟัะธัะฐัะธัััั{}, // ะฟัะธัะฐัะธัััั ะฝะฐ ะณัะปัะฝะบั
rus_verbs:ะพัะตััะฐัั{}, // ะพัะตััะฐัั ะฝะฐ ะฟัะธัะปัะณั
rus_verbs:ะฝะฐััะฐะฒะธัั{}, // ะฝะฐััะฐะฒะธัั ะฝะฐ ะผะตะดะฒะตะดั
rus_verbs:ัััะฟะฐัั{}, // ัััะฟะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฟะพะดะฒะพะทะธัั{}, // ะฟะพะดะฒะพะทะธัั ะฝะฐ ะฟัะธััะฐะฝั
rus_verbs:ะผะพะฑะธะปะธะทะพะฒะฐัั{}, // ะผะพะฑะธะปะธะทะพะฒะฐัั ะฝะฐ ัะฑะพัั
rus_verbs:ัะผะพัะฐัััั{}, // ัะผะพัะฐัััั ะฝะฐ ัะฐะฑะพัั
rus_verbs:ะทะฐะณะปัะดะตัััั{}, // ะทะฐะณะปัะดะตัััั ะฝะฐ ะดะตะฒัะพะฝะพะบ
rus_verbs:ัะฐัะบะฐัััั{}, // ัะฐัะบะฐัััั ะฝะฐ ัะฐะฑะพัั
rus_verbs:ัะฐะทะณััะถะฐัั{}, // ัะฐะทะณััะถะฐัั ะฝะฐ ััะฐะฝัะฟะพััะตั
rus_verbs:ะฟะพััะตะฑะปััั{}, // ะฟะพััะตะฑะปััั ะฝะฐ ะบะพะฝะดะธัะธะพะฝะธัะพะฒะฐะฝะธะต
ะธะฝัะธะฝะธัะธะฒ:ัะณะพะฝััั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะณะพะฝััั{ ะฒะธะด:ัะพะฒะตัั }, // ัะณะพะฝััั ะฝะฐ ะฑะฐะทั
ะดะตะตะฟัะธัะฐััะธะต:ัะณะพะฝัะฒ{},
rus_verbs:ะฟะพััะปะฐัััั{}, // ะฟะพััะปะฐัััั ะฝะฐ ัะฐะทะฒะตะดะบั
rus_verbs:ะพะบัััะธัััั{}, // ะพะบัััะธัััั ะฝะฐ ะบะพะณะพ-ัะพ
rus_verbs:ะพัะปะธัั{}, // ะพัะปะธัั ะฝะฐ ัะบะพะฒะพัะพะดั
rus_verbs:ัะธะบะฝััั{}, // ัะธะบะฝััั ะฝะฐ ะดะตัะธัะตะบ
rus_verbs:ัะฟะพะฒะฐัั{}, // ัะฟะพะฒะฐัั ะฝะฐ ะฑะตัะบะพัััะฝัั ะฟะพะผะพัั
rus_verbs:ะบะปะฐััััั{}, // ะบะปะฐััััั ะฝะฐ ััะพะป
rus_verbs:ะฟะพะบะพะฒัะปััั{}, // ะฟะพะบะพะฒัะปััั ะฝะฐ ะฒัั
ะพะด
rus_verbs:ะฝะฐะฒะตะฒะฐัั{}, // ะฝะฐะฒะตะฒะฐัั ะฝะฐ ัะพะฑัะฐะฒัะธั
ัั ัะบัะบั
rus_verbs:ะฝะฐะบะปะฐะดัะฒะฐัััั{}, // ะฝะฐะบะปะฐะดัะฒะฐัััั ะฝะฐ ะณััะฝัะพะฒะบั
rus_verbs:ะฝะฐะฝะพัะธัััั{}, // ะฝะฐะฝะพัะธัััั ะฝะฐ ัะธัััั ะบะพะถั
// rus_verbs:ะทะฐะฟะปะฐะฝะธัะพะฒะฐัั{}, // ะทะฐะฟะปะฐะฝะธัะพะฒะฐัั ะฝะฐ ััะตะดั
rus_verbs:ะบัะฒััะบะฝััััั{}, // ะบัะฒััะบะฝััััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะณะฐะฒะบะฝััั{}, // ะณะฐะฒะบะฝััั ะฝะฐ ั
ะพะทัะธะฝะฐ
rus_verbs:ะฟะตัะตัััะพะธัััั{}, // ะฟะตัะตัััะพะธัััั ะฝะฐ ะฝะพะฒัะน ะปะฐะด
rus_verbs:ัะฐัั
ะพะดะพะฒะฐัััั{}, // ัะฐัั
ะพะดะพะฒะฐัััั ะฝะฐ ะพะฑัะฐะทะพะฒะฐะฝะธะต
rus_verbs:ะดััััั{}, // ะดััััั ะฝะฐ ะฑะฐะฑััะบั
rus_verbs:ะฟะตัะตัะฐัะบะธะฒะฐัั{}, // ะฟะตัะตัะฐัะบะธะฒะฐัั ะฝะฐ ัะฐะฑะพัะธะน ััะพะป
rus_verbs:ะธะทะดะฐัััั{}, // ะธะทะดะฐัััั ะฝะฐ ะดะตะฝัะณะธ ัะฟะพะฝัะพัะพะฒ
rus_verbs:ัะผะตัะฐัััั{}, // ัะผะตัะฐัััั ะฝะฐ ะฝะตัะบะพะปัะบะพ ะผะธะปะปะธะผะตััะพะฒ
rus_verbs:ะทะฐะทัะฒะฐัั{}, // ะทะฐะทัะฒะฐัั ะฝะฐ ะฝะพะฒะพะณะพะดะฝัั ัะฐัะฟัะพะดะฐะถั
rus_verbs:ะฟะธะบะธัะพะฒะฐัั{}, // ะฟะธะบะธัะพะฒะฐัั ะฝะฐ ะพะบะพะฟั
rus_verbs:ัะตัััั
ะฐัััั{}, // ัะตัััั
ะฐัััั ะฝะฐ ะผะตัะฐััะธั
ัั ะดะตัะตะน
rus_verbs:ะทัะดะธัั{}, // ะทัะดะธัั ะฝะฐ ัั
ะพ
rus_verbs:ะฟะพะดัะฐะทะดะตะปััััั{}, // ะฟะพะดัะฐะทะดะตะปััััั ะฝะฐ ะณััะฟะฟั
rus_verbs:ะธะทะปะธะฒะฐัััั{}, // ะธะทะปะธะฒะฐัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฟะพะผะพัะธัััั{}, // ะฟะพะผะพัะธัััั ะฝะฐ ััะฐะฒั
rus_verbs:ะฟัะธะผะตัััั{}, // ะฟัะธะผะตัััั ะฝะฐ ัะตะฑั
rus_verbs:ัะฐะทััะดะธัััั{}, // ัะฐะทััะดะธัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะผะพัะฝััััั{}, // ะผะพัะฝััััั ะฝะฐ ะบัััั
rus_verbs:ะฝะฐะปะตะณะฐัั{}, // ะฝะฐะปะตะณะฐัั ะฝะฐ ะฒะตัะปะฐ
rus_verbs:ะทะฐัะพะบะฐัั{}, // ะทะฐัะพะบะฐัั ะฝะฐ ะบััะธั
rus_verbs:ะฝะฐะฝะธะผะฐัััั{}, // ะฝะฐะฝะธะผะฐัััั ะฝะฐ ะบะพัะฐะฑะปั
rus_verbs:ัะฟะปะตะฒัะฒะฐัั{}, // ัะฟะปะตะฒัะฒะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฝะฐััััะฐัั{}, // ะฝะฐััััะฐัั ะฝะฐ ัะฐะฑะพัะฐะถะฝะธะบะฐ
rus_verbs:ะฟัะธะทะตะผะปััััั{}, // ะฟัะธะทะตะผะปััััั ะฝะฐ ะฑััั
ะพ
rus_verbs:ะฝะฐัะฐะปะบะธะฒะฐัััั{}, // ะฝะฐัะฐะปะบะธะฒะฐัััั ะฝะฐ ะพะฑัะตะบัะธะฒะฝัะต ัััะดะฝะพััะธ
rus_verbs:ะฟะพัะธะณะฝะฐะปะธัั{}, // ะฟะพัะธะณะฝะฐะปะธัั ะฝะฐัััะธัะตะปั, ะฒัะตั
ะฐะฒัะตะผั ะฝะฐ ะฒัััะตัะฝัั ะฟะพะปะพัั
rus_verbs:ัะตััะฐัั{}, // ัะตััะฐัั ะฝะฐ ะฝะตัะฐััะพัะพะฟะฝัั ะฟะพะผะพัะฝะธัั
rus_verbs:ัะฒะฐะปะธะฒะฐัั{}, // ัะฒะฐะปะธะฒะฐัั ะฝะฐ ะฟะพะดะพะบะพะฝะฝะธะบ
rus_verbs:ะทะฐัะพะฑะธัะฐัััั{}, // ะทะฐัะพะฑะธัะฐัััั ะฝะฐ ัะฐะฑะพัั
rus_verbs:ัะฐัะฟะธะปะธัั{}, // ัะฐัะฟะธะปะธัั ะฝะฐ ะพะดะธะฝะฐะบะพะฒัะต ะฑัััะบะธ
//rus_verbs:ัะผะฝะพะถะฐัั{}, // ัะผะฝะพะถะฐัั ะฝะฐ ะบะพะฝััะฐะฝัั
rus_verbs:ะบะพะฟะธัะพะฒะฐัั{}, // ะบะพะฟะธัะพะฒะฐัั ะฝะฐ ะดะธัะบ
rus_verbs:ะฝะฐะบัััะธัั{}, // ะฝะฐะบัััะธัั ะฝะฐ ััะบั
rus_verbs:ะฝะฐะฒะฐะปะธัั{}, // ะฝะฐะฒะฐะปะธัั ะฝะฐ ัะตะปะตะณั
rus_verbs:ะฝะฐัะพะปะบะฝััั{}, // ะฝะฐัะพะปะบะฝััั ะฝะฐ ัะฒะตะถัั ะผััะปั
rus_verbs:ัะปะตะฟะฐัััั{}, // ัะปะตะฟะฐัััั ะฝะฐ ะฑะตัะพะฝ
rus_verbs:ัั
ะปะพะฟะฐัั{}, // ัั
ะปะพะฟะฐัั ะฝะฐ ัะบัะฟะบั ะฟัะพะธะทะฒะตะดะตะฝะธะน ะธัะบััััะฒะฐ
rus_verbs:ะทะฐะผะฐั
ะธะฒะฐัััั{}, // ะทะฐะผะฐั
ะธะฒะฐัััั ะฝะฐ ะฐะฒัะพัะธัะตัะฝะตะนัะตะต ะผะฝะตะฝะธะต
rus_verbs:ะฟะพััะณะฝััั{}, // ะฟะพััะณะฝััั ะฝะฐ ัะฒััะพะต
rus_verbs:ัะฐะทะผะตะฝััั{}, // ัะฐะทะผะตะฝััั ะฝะฐ ะผะตะปะพัั
rus_verbs:ะพัะบะฐััะฒะฐัััั{}, // ะพัะบะฐััะฒะฐัััั ะฝะฐ ะทะฐัะฐะฝะตะต ะฟะพะดะณะพัะพะฒะปะตะฝะฝัะต ะฟะพะทะธัะธะธ
rus_verbs:ััะฐะถะธะฒะฐัั{}, // ััะฐะถะธะฒะฐัั ะฝะฐ ัะบะฐะผะตะนะบั
rus_verbs:ะฝะฐัะฐัะบะฐัั{}, // ะฝะฐัะฐัะบะฐัั ะฝะฐ ะฟะพะธัะบ ะฝะฐัะบะพัะธะบะพะฒ
rus_verbs:ะทะฐัะธะบะฐัั{}, // ะทะฐัะธะบะฐัั ะฝะฐ ะบะพัะบั
rus_verbs:ัะฐะทะปะพะผะฐัั{}, // ัะฐะทะปะพะผะฐัั ะฝะฐ ัะฐะฒะฝัะต ัะฐััะธ
rus_verbs:ะฟัะธะณะปะฐัะฐัััั{}, // ะฟัะธะณะปะฐัะฐัััั ะฝะฐ ััะตะฝั
rus_verbs:ะฟัะธััะณะฐัั{}, // ะฟัะธััะณะฐัั ะฝะฐ ะฒะตัะฝะพััั
rus_verbs:ะทะฐะฟัะพะณัะฐะผะผะธัะพะฒะฐัั{}, // ะทะฐะฟัะพะณัะฐะผะผะธัะพะฒะฐัั ะฝะฐ ะฟะพััะพัะฝะฝัั ัะฑะพัะบั
rus_verbs:ัะฐััะตะดัะธัััั{}, // ัะฐััะตะดัะธัััั ะฝะฐ ะฝะพะฒัะน ะบะพะผะฟัััะตั
rus_verbs:ะฝะฐัะตััั{}, // ะฝะฐัะตััั ะฝะฐ ะดะฒะพะตัะฝะธะบะพะฒ
rus_verbs:ัะพะทัะฒะฐัั{}, // ัะพะทัะฒะฐัั ะฝะฐ ัะพะฑัะฐะฝะธะต
rus_verbs:ะฟะพะทะฐัะธัััั{}, // ะฟะพะทะฐัะธัััั ะฝะฐ ััะถะพะต ะดะพะฑัะพ
rus_verbs:ะฟะตัะตะบะธะดัะฒะฐัััั{}, // ะฟะตัะตะบะธะดัะฒะฐัััั ะฝะฐ ัะพัะตะดะฝะธะต ะทะดะฐะฝะธั
rus_verbs:ะฝะฐะฟะพะปะทะฐัั{}, // ะฝะฐะฟะพะปะทะฐัั ะฝะฐ ะฝะตะฟะพะฒัะตะถะดะตะฝะฝัั ัะบะฐะฝั
rus_verbs:ะธะทััะฑะธัั{}, // ะธะทััะฑะธัั ะฝะฐ ะผะตะปะบะธะต ะบััะพัะบะธ
rus_verbs:ะฝะฐะฒะพัะฐัะธะฒะฐัััั{}, // ะฝะฐะฒะพัะฐัะธะฒะฐัััั ะฝะฐ ะณะปะฐะทะฐ
rus_verbs:ัะฐัะบัะธัะฐัััั{}, // ัะฐัะบัะธัะฐัััั ะฝะฐ ะฒัั ะพะบััะณั
rus_verbs:ะฟะตัะตะฟะพะปะทัะธ{}, // ะฟะตัะตะฟะพะปะทัะธ ะฝะฐ ัะฒะตัะปัั ััะพัะพะฝั
rus_verbs:ัะฟะพะปะฝะพะผะพัะธัั{}, // ัะฟะพะปะฝะพะผะพัะธัั ะฝะฐ ัะฐะทะฒะตะดะพะฒะฐัะตะปัะฝัั ะพะฟะตัะฐัะธั
rus_verbs:ะผะพัะธัััั{}, // ะผะพัะธัััั ะฝะฐ ัััะฟั ัะฑะธััั
ะฒัะฐะณะพะฒ
rus_verbs:ัะฐะดะธัะพะฒะฐัั{}, // ัะฐะดะธัะพะฒะฐัั ะฝะฐ ะฑะฐะทั
rus_verbs:ะฟัะพะผะพัะฐัั{}, // ะฟัะพะผะพัะฐัั ะฝะฐ ะฝะฐัะฐะปะพ
rus_verbs:ะทะฐัะฝััั{}, // ะทะฐัะฝััั ะฝะฐ ะฒะธะดะตะพ
rus_verbs:ะฟะพะดะฑะธะฒะฐัั{}, // ะฟะพะดะฑะธะฒะฐัั ะฝะฐ ะผะฐัั-ัะตะฒะฐะฝั
rus_verbs:ะฝะฐะฟะปะตะฒะฐัั{}, // ะฝะฐะฟะปะตะฒะฐัั ะฝะฐ ัะฟัะฐะฒะตะดะปะธะฒะพััั
rus_verbs:ะฟะพะดะฒัะฒะฐัั{}, // ะฟะพะดะฒัะฒะฐัั ะฝะฐ ะปัะฝั
rus_verbs:ัะฐัะฟะปะตัะบะฐัั{}, // ัะฐัะฟะปะตัะบะฐัั ะฝะฐ ะฟะพะป
rus_verbs:ะฟะพะปัััะธัััั{}, // ะฟะพะปัััะธัััั ะฝะฐ ะฑะตัะฟะปะฐัะฝัะน ััั
rus_verbs:ะฟะพะผัะฐัั{}, // ะฟะพะผัะฐัั ะฝะฐ ัะฐะฑะพัั
rus_verbs:ััะตะทะถะฐัั{}, // ััะตะทะถะฐัั ะฝะฐ ะพะฑะพัะธะฝั
rus_verbs:ะฝะฐัะตะฟัะฐัั{}, // ะฝะฐัะตะฟัะฐัั ะบะพะผั-ัะพ ะฝะฐ ัั
ะพ
rus_verbs:ะฝะฐะบะปะตะธัั{}, // ะฝะฐะบะปะตะธัั ะฝะฐ ะดะพัะบั ะพะฑััะฒะปะตะฝะธะน
rus_verbs:ะทะฐะฒะพะทะธัั{}, // ะทะฐะฒะพะทะธัั ะฝะฐ ัะบะปะฐะด
rus_verbs:ะทะฐัะฒะปััััั{}, // ะทะฐัะฒะปััััั ะฝะฐ ะปัะฑะธะผัั ัะฐะฑะพัั
rus_verbs:ะฝะฐะณะปัะดะตัััั{}, // ะฝะฐะณะปัะดะตัััั ะฝะฐ ะฒะพัะพะฑัะตะฒ
rus_verbs:ั
ะปะพะฟะฝััััั{}, // ั
ะปะพะฟะฝััััั ะฝะฐ ะถะธะฒะพั
rus_verbs:ะทะฐะฑัะตะดะฐัั{}, // ะทะฐะฑัะตะดะฐัั ะฝะฐ ะฟะพะปัะฝั
rus_verbs:ะฟะพััะณะฐัั{}, // ะฟะพััะณะฐัั ะฝะฐ ะธัะบะพะฝะฝัะต ะฟัะฐะฒะฐ ัะพะฑััะฒะตะฝะฝะพััะธ
rus_verbs:ัะดะฒะธะณะฐัั{}, // ัะดะฒะธะณะฐัั ะฝะฐ ะพะดะฝั ะฟะพะทะธัะธั
rus_verbs:ัะฟััะณะธะฒะฐัั{}, // ัะฟััะณะธะฒะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะดะฒะธะณะฐัััั{}, // ัะดะฒะธะณะฐัััั ะฝะฐ ะดะฒะต ะฟะพะทะธัะธะธ
rus_verbs:ัะฐะทะดะตะปะฐัั{}, // ัะฐะทะดะตะปะฐัั ะฝะฐ ะพัะตั
ะธ
rus_verbs:ัะฐะทะปะฐะณะฐัั{}, // ัะฐะทะปะฐะณะฐัั ะฝะฐ ัะปะตะผะตะฝัะฐัะฝัะต ัะปะตะผะตะฝัั
rus_verbs:ะพะฑัััะธะฒะฐัั{}, // ะพะฑัััะธะฒะฐัั ะฝะฐ ะณะพะปะพะฒั ะฒัะฐะณะพะฒ
rus_verbs:ะฝะฐัะตัั{}, // ะฝะฐัะตัั ะฝะฐ ะฟะพะป
rus_verbs:ะฟะพะปะธัััั{}, // ะฒะพะดะฐ ะฟะพะปัะตััั ะฝะฐ ะทะตะผะปั
rus_verbs:ััะฟะตัั{}, // ะะฝะธ ััะฟะตัั ะฝะฐ ะฟะพะตะทะด.
ะธะฝัะธะฝะธัะธะฒ:ะผะธะณัะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ะผะธะณัะธัะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะผะธะณัะธััั{},
ะธะฝัะธะฝะธัะธะฒ:ะผะธะณัะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะผะธะณัะธัะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ะผะธะณัะธัะพะฒะฐะฒ{},
rus_verbs:ะดะฒะธะฝััััั{}, // ะั ัะบะพัะพ ะดะฒะธะฝะตะผัั ะฝะฐ ะดะฐัั.
rus_verbs:ะฟะพะดะพะนัะธ{}, // ะะฝ ะฝะต ะฟะพะดะพะนะดัั ะฝะฐ ะดะพะปะถะฝะพััั ัะตะบัะตัะฐัั.
rus_verbs:ะฟะพััะฝััั{}, // ะะฝ ะฝะต ะฟะพััะฝะตั ะฝะฐ ะดะธัะตะบัะพัะฐ.
rus_verbs:ััะฝััั{}, // ะะฝ ะฝะต ััะฝะตั ะฝะฐ ะดะธัะตะบัะพัะฐ.
rus_verbs:ะฟะตัะตัะบะฐะบะธะฒะฐัั{}, // ะฟะตัะตัะบะฐะบะธะฒะฐัั ั ะพะดะฝะพะณะพ ะฟัะธะผะตัะฐ ะฝะฐ ะดััะณะพะน
rus_verbs:ะถะฐะปะพะฒะฐัััั{}, // ะะฝ ะถะฐะปัะตััั ะฝะฐ ะฝะตะทะดะพัะพะฒัะต.
rus_verbs:ะธะทะดะฐัั{}, // ะธะทะดะฐัั ะฝะฐ ะดะตะฝัะณะธ ัะฟะพะฝัะพัะพะฒ
rus_verbs:ะฟะพะบะฐะทะฐัััั{}, // ะฟะพะบะฐะทะฐัััั ะฝะฐ ะณะปะฐะทะฐ
rus_verbs:ะฒััะฐะถะธะฒะฐัั{}, // ะฒััะฐะถะธะฒะฐัั ะฝะฐ ะฝะตะพะฑะธัะฐะตะผัะน ะพัััะพะฒ
rus_verbs:ะฒะพะทะฝะตััะธัั{}, // ะฒะพะทะฝะตััะธัั ะฝะฐ ัะฐะผัั ะฒะตััะธะฝั ัะปะฐะฒั
rus_verbs:ะทะฐะปะธัั{}, // ะทะฐะปะธัั ะฝะฐ youtube
rus_verbs:ะทะฐะบะฐัะฐัั{}, // ะทะฐะบะฐัะฐัั ะฝะฐ youtube
rus_verbs:ััะณัะฐัั{}, // ััะณัะฐัั ะฝะฐ ะดะตะฝัะณะธ
rus_verbs:ัะบัััะฐะฟะพะปะธัะพะฒะฐัั{}, // ะคะพัะผัะปั ะผะพะถะฝะพ ัะบัััะฐะฟะพะปะธัะพะฒะฐัั ะฝะฐ ัะปััะฐะน ะฝะตัะบะพะปัะบะธั
ะฟะตัะตะผะตะฝะฝัั
ะธะฝัะธะฝะธัะธะฒ:ัะบัััะฐะฟะพะปะธัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะกะธััะฐัะธั ะปะตะณะบะพ ัะบัััะฐะฟะพะปะธััะตััั ะฝะฐ ัะปััะฐะน ะฝะตัะบะพะปัะบะธั
ะฟะตัะตะผะตะฝะฝัั
ะณะปะฐะณะพะป:ัะบัััะฐะฟะพะปะธัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั},
ะธะฝัะธะฝะธัะธะฒ:ัะบัััะฐะฟะพะปะธัะพะฒะฐัััั{ ะฒะธะด:ัะพะฒะตัั},
ะณะปะฐะณะพะป:ัะบัััะฐะฟะพะปะธัะพะฒะฐัััั{ ะฒะธะด:ัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ัะบัััะฐะฟะพะปะธััััั{},
ะธะฝัะธะฝะธัะธะฒ:ะฐะบัะตะฝัะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั}, // ะพัะฐัะพั ะฐะบัะตะฝัะธัะพะฒะฐะป ะฒะฝะธะผะฐะฝะธะต ัะปััะฐัะตะปะตะน ะฝะฐ ะฝะพะฒัะน ะฐัะฟะตะบั ะฟัะพะฑะปะตะผั
ะณะปะฐะณะพะป:ะฐะบัะตะฝัะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะธะฝัะธะฝะธัะธะฒ:ะฐะบัะตะฝัะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฐะบัะตะฝัะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะบัะตะฝัะธัะพะฒะฐะฒัะธะน{ะฒะธะด:ะฝะตัะพะฒะตัั},
//ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะบัะตะฝัะธัะพะฒะฐะฒัะธะน{ะฒะธะด:ัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะบัะตะฝัะธััััะธะน{},
ะดะตะตะฟัะธัะฐััะธะต:ะฐะบัะตะฝัะธัะพะฒะฐะฒ{},
ะดะตะตะฟัะธัะฐััะธะต:ะฐะบัะตะฝัะธััั{},
rus_verbs:ะฑะฐะฑะฐั
ะฐัััั{}, // ะพะฝ ะฑะฐะฑะฐั
ะฐะปัั ะฝะฐ ะฟะพะป
rus_verbs:ะฑะฐะฑะฐั
ะฝััััั{}, // ะผะฐะปััะธะป ะฑะฐะฑะฐั
ะฝัะปัั ะฝะฐ ะฐััะฐะปัั
rus_verbs:ะฑะฐััะฐัะธัั{}, // ะัะตััััะฝะต ะฑะฐััะฐัะธะปะธ ะฝะฐ ั
ะพะทัะธะฝะฐ
rus_verbs:ะฑะฐั
ะฐัััั{}, // ะะฐะตะทะดะฝะธะบะธ ะฑะฐั
ะฐะปะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฑะฐั
ะฝััััั{}, // ะะฐะตะทะดะฝะธะบ ะพะฟััั ะฑะฐั
ะฝัะปัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฑะปะฐะณะพัะปะพะฒะธัั{}, // ะฑะฐัััะบะฐ ะฑะปะฐะณะพัะปะพะฒะธะป ะพััะพะบะฐ ะฝะฐ ะฟะพะดะฒะธะณ
rus_verbs:ะฑะปะฐะณะพัะปะพะฒะปััั{}, // ะฑะฐัััะบะฐ ะฑะปะฐะณะพัะปะพะฒะปัะตั ะพััะพะบะฐ ะฝะฐ ะฟะพะดะฒะธะณ
rus_verbs:ะฑะปะตะฒะฐะฝััั{}, // ะะฝ ะฑะปะตะฒะฐะฝัะป ะฝะฐ ะทะตะผะปั
rus_verbs:ะฑะปะตะฒะฐัั{}, // ะะฝ ะฑะปัะตั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฑัั
ะฝััััั{}, // ะะฐะตะทะดะฝะธะบ ะฑัั
ะฝัะปัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒะฐะปะธัั{}, // ะะตัะตั ะฒะฐะปะธะป ะดะตัะตะฒัั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะฟะธะปะธัั{}, // ะกะฟะธะปะตะฝะฝะพะต ะดะตัะตะฒะพ ะฒะฐะปะธััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒะฒะตะทัะธ{}, // ะัะตะดะฟัะธััะธะต ะฒะฒะตะทะปะพ ัะพะฒะฐั ะฝะฐ ัะฐะผะพะถะฝั
rus_verbs:ะฒะดะพั
ะฝะพะฒะธัั{}, // ะคะธะปัะผ ะฒะดะพั
ะฝะพะฒะธะป ะผะฐะปััะธะบะฐ ะฝะฐ ะฟะพั
ะพะด ะฒ ะปะตั
rus_verbs:ะฒะดะพั
ะฝะพะฒะธัััั{}, // ะะฐะปััะธะบ ะฒะดะพั
ะฝะพะฒะธะปัั ะฝะฐ ะฟะพั
ะพะด
rus_verbs:ะฒะดะพั
ะฝะพะฒะปััั{}, // ะคะธะปัะผ ะฒะดะพั
ะฝะพะฒะปัะตั ะฝะฐ ะฟะพั
ะพะด ะฒ ะปะตั
rus_verbs:ะฒะตััะธัั{}, // ะะต ะฒะตะดะธัั ะฝะฐ ััะธ ัะปะพะฒะบะธ!
rus_verbs:ะฒะตัะฐัั{}, // ะะพััะธ ะฒะตัะฐัั ะพะดะตะถะดั ะฝะฐ ะฒะตัะฐะปะบั
rus_verbs:ะฒะตัะฐัััั{}, // ะะดะตะถะดะฐ ะฒะตัะฐะตััั ะฝะฐ ะฒะตัะฐะปะบะธ
rus_verbs:ะฒะตัะฐัั{}, // ัะฐะดะธะพััะฐะฝัะธั ะฒะตัะฐะตั ะฝะฐ ะฒัั ัััะฐะฝั
rus_verbs:ะฒะทะฑะธัะฐัััั{}, // ะขััะธััั ะฒะทะฑะธัะฐัััั ะฝะฐ ะทะฐัะพััะธะน ะปะตัะพะผ ั
ะพะปะผ
rus_verbs:ะฒะทะฑัะตะดะฐัั{}, // ะงัะพ ะธะฝะพะณะดะฐ ะฒะทะฑัะตะดะฐะตั ะฝะฐ ัะผ
rus_verbs:ะฒะทะฑัะตััะธ{}, // ะงัะพ-ัะพ ะฒะทะฑัะตะปะพ ะฝะฐ ัะผ
rus_verbs:ะฒะทะฒะฐะปะธัั{}, // ะะฐะผะฐ ะฒะทะฒะฐะปะธะปะฐ ะฝะฐ ัะฒะพะธ ะฟะปะตัะธ ะฒัั ะดะพะผะฐัะฝะตะต ั
ะพะทัะนััะฒะพ
rus_verbs:ะฒะทะฒะฐะปะธะฒะฐัััั{}, // ะัะต ะดะพะผะฐัะฝะตะต ั
ะพะทัะนััะฒะพ ะฒะทะฒะฐะปะธะฒะฐะตััั ะฝะฐ ะผะฐะผะธะฝั ะฟะปะตัะธ
rus_verbs:ะฒะทะฒะฐะปะธะฒะฐัั{}, // ะะต ะฝะฐะดะพ ะฒะทะฒะฐะปะธะฒะฐัั ะฒัั ะฝะฐ ะผะพะธ ะฟะปะตัะธ
rus_verbs:ะฒะทะณะปัะฝััั{}, // ะะพัะบะฐ ะฒะทะณะปัะฝัะปะฐ ะฝะฐ ะผััะบั
rus_verbs:ะฒะทะณัะพะผะพะถะดะฐัั{}, // ะะฐะปััะธะบ ะฒะทะณัะพะผะพะถะดะฐะตั ัััะป ะฝะฐ ััะพะป
rus_verbs:ะฒะทะณัะพะผะพะถะดะฐัััั{}, // ะะฐะปััะธะบ ะฒะทะณัะพะผะพะถะดะฐะตััั ะฝะฐ ััะพะป
rus_verbs:ะฒะทะณัะพะผะพะทะดะธัั{}, // ะะฐะปััะธะบ ะฒะทะณัะพะผะพะทะดะธะป ัััะป ะฝะฐ ััะพะป
rus_verbs:ะฒะทะณัะพะผะพะทะดะธัััั{}, // ะะฐะปััะธะบ ะฒะทะณัะพะผะพะทะดะธะปัั ะฝะฐ ัััะป
rus_verbs:ะฒะทะธัะฐัั{}, // ะัะตะฒะธะดัั ะฒะทะธัะฐะปะธ ะฝะฐ ะฝะตะฟะพะฝััะฝัะน ะพะฑัะตะบั
rus_verbs:ะฒะทะปะตัะฐัั{}, // ะคะฐะฑัะธะบะฐ ัะตะนะตัะฒะตัะบะพะฒ ะฒะทะปะตัะฐะตั ะฝะฐ ะฒะพะทะดัั
rus_verbs:ะฒะทะปะตัะตัั{}, // ะคะฐะฑัะธะบะฐ ัะตะนะตัะฒะตัะบะพะฒ ะฒะทะปะตัะตะปะฐ ะฝะฐ ะฒะพะทะดัั
rus_verbs:ะฒะทะพะฑัะฐัััั{}, // ะขััะธััั ะฒะทะพะฑัะฐะปะธัั ะฝะฐ ะณะพัั
rus_verbs:ะฒะทะพะนัะธ{}, // ะขััะธััั ะฒะทะพัะปะธ ะฝะฐ ะณะพัั
rus_verbs:ะฒะทัะตััััั{}, // ะัะตั ะฒะทัะตะปัั ะฝะฐ ะฝะตะฟััะตะฒะพะณะพ ััะฝะฐ
rus_verbs:ะฒะทัััะธัััั{}, // ะัะตั ะฒะทัััะธะปัั ะฝะฐ ะฝะตะฟััะตะฒะพะณะพ ััะฝะฐ
rus_verbs:ะฒะบะฐัะธัั{}, // ัะฐะฑะพัะธะต ะฒะบะฐัะธะปะธ ะฑะพัะบั ะฝะฐ ะฟะฐะฝะดัั
rus_verbs:ะฒะบะฐััะฒะฐัั{}, // ัะฐะฑะพัะธะบ ะฒะบะฐััะฒะฐัั ะฑะพัะบั ะฝะฐ ะฟะฐะฝะดัั
rus_verbs:ะฒะปะธััั{}, // ะญัะพ ัะตัะตะฝะธะต ะฒะปะธัะตั ะฝะฐ ะฒัะตั
ะธะณัะพะบะพะฒ ััะฝะบะฐ
rus_verbs:ะฒะพะดะฒะพัะธัั{}, // ะฒะพะดะฒะพัะธัั ะฝะฐัััะธัะตะปั ะฝะฐ ะผะตััะพ
rus_verbs:ะฒะพะดะฒะพัะธัััั{}, // ะฒะพะดะฒะพัะธัััั ะฝะฐ ัะฒะพะต ะผะตััะพ
rus_verbs:ะฒะพะดะฒะพัััั{}, // ะฒะพะดะฒะพัััั ะฒะตัั ะฝะฐ ัะฒะพะต ะผะตััะพ
rus_verbs:ะฒะพะดะฒะพัััััั{}, // ะฒะพะดะฒะพัััััั ะฝะฐ ัะฒะพะต ะผะตััะพ
rus_verbs:ะฒะพะดััะถะฐัั{}, // ะฒะพะดััะถะฐัั ัะปะฐะณ ะฝะฐ ัะปะฐะณััะพะบ
rus_verbs:ะฒะพะดััะถะฐัััั{}, // ะคะปะฐะณ ะฒะพะดััะถะฐะตััั ะฝะฐ ัะปะฐะณััะพะบ
rus_verbs:ะฒะพะดััะทะธัั{}, // ะฒะพะดััะทะธัั ัะปะฐะณ ะฝะฐ ัะปะฐะณััะพะบ
rus_verbs:ะฒะพะดััะทะธัััั{}, // ะคะปะฐะณ ะฒะพะดััะทะธะปัั ะฝะฐ ะฒะตััะธะฝั ะณะพัั
rus_verbs:ะฒะพะทะดะตะนััะฒะพะฒะฐัั{}, // ะะทะปััะตะฝะธะต ะฒะพะทะดะตะนััะฒัะตั ะฝะฐ ะบะพะถั
rus_verbs:ะฒะพะทะทัะตัั{}, // ะฒะพะทะทัะตัั ะฝะฐ ะฟะพะปะต ะฑะพั
rus_verbs:ะฒะพะทะทัะธัััั{}, // ะฒะพะทะทัะธัััั ะฝะฐ ะฟะพะปะต ะฑะพั
rus_verbs:ะฒะพะทะธัั{}, // ะฒะพะทะธัั ัััะธััะพะฒ ะฝะฐ ะณะพัั
rus_verbs:ะฒะพะทะปะฐะณะฐัั{}, // ะะฝะพะณะพัะธัะปะตะฝะฝัะต ะฟะพัะตัะธัะตะปะธ ะฒะพะทะปะฐะณะฐัั ัะฒะตัั ะฝะฐ ะผะพะณะธะปั
rus_verbs:ะฒะพะทะปะฐะณะฐัััั{}, // ะัะฒะตัััะฒะตะฝะฝะพััั ะฒะพะทะปะฐะณะฐะตััั ะฝะฐ ะฝะฐัะฐะปัััะฒะพ
rus_verbs:ะฒะพะทะปะตัั{}, // ะฒะพะทะปะตัั ะฝะฐ ะปะตะถะฐะฝะบั
rus_verbs:ะฒะพะทะปะพะถะธัั{}, // ะฒะพะทะปะพะถะธัั ัะฒะตัั ะฝะฐ ะผะพะณะธะปั ะฟะพััะฐ
rus_verbs:ะฒะพะทะฝะตััะธ{}, // ะฒะพะทะฝะตััะธ ะบะพะณะพ-ัะพ ะฝะฐ ะฒะตััะธะฝั ัะปะฐะฒั
rus_verbs:ะฒะพะทะฝะพัะธัััั{}, // ะฒะพะทะฝะพัะธััั ะฝะฐ ะฒะตััะธะฝั ััะฟะตั
ะฐ
rus_verbs:ะฒะพะทะฝะพัะธัั{}, // ะฒะพะทะฝะพัะธัั ััะฐััะปะธะฒัะธะบะฐ ะฝะฐ ะฒะตััะธะฝั ััะฟะตั
ะฐ
rus_verbs:ะฟะพะดะฝะธะผะฐัััั{}, // ะั ะฟะพะดะฝะธะผะฐะตะผัั ะฝะฐ ะฒะพััะผะพะน ััะฐะถ
rus_verbs:ะฟะพะดะฝััััั{}, // ะั ะฟะพะดะฝัะปะธัั ะฝะฐ ะฒะพััะผะพะน ััะฐะถ
rus_verbs:ะฒะพะฝััั{}, // ะััะพะบ ัััะฐ ะฒะพะฝัะตั ะฝะฐ ะฒัั ะพะบััะณั
rus_verbs:ะฒะพะพะดััะตะฒะปััั{}, // ะะดะตะฐะปั ะฒะพะพะดััะตะฒะปััั ะฝะฐ ะฟะพะดะฒะธะณะธ
rus_verbs:ะฒะพะพะดััะตะฒะปััััั{}, // ะัะดะธ ะฒะพะพะดััะตะฒะปััััั ะฝะฐ ะฟะพะดะฒะธะณะธ
rus_verbs:ะฒะพััะฐัั{}, // ะกัะฐััะน ะฟะตั ะฒะพััะธั ะฝะฐ ะฟัะพั
ะพะถะธั
rus_verbs:ะฒะพัะฟัะธะฝะธะผะฐัั{}, // ะฒะพัะฟัะธะฝะธะผะฐัั ัะพะพะฑัะตะฝะธะต ะฝะฐ ัะปัั
rus_verbs:ะฒะพัะฟัะธะฝะธะผะฐัััั{}, // ัะพะพะฑัะตะฝะธะต ะฟะปะพั
ะพ ะฒะพัะฟัะธะฝะธะผะฐะตััั ะฝะฐ ัะปัั
rus_verbs:ะฒะพัะฟัะธะฝััั{}, // ะฒะพัะฟัะธะฝััั ัะพะพะฑัะตะฝะธะต ะฝะฐ ัะปัั
rus_verbs:ะฒะพัะฟัะธะฝััััั{}, // ะฒะพัะฟัะธะฝััััั ะฝะฐ ัะปัั
rus_verbs:ะฒะพััะตััั{}, // ะะพะปั ะฒะพััะตะป ะฝะฐ ััะพะฝ
rus_verbs:ะฒะฟัะฐะฒะธัั{}, // ะฒะฟัะฐะฒะธัั ะผะพะทะณ ะฝะฐ ะผะตััะพ
rus_verbs:ะฒะฟัะฐะฒะปััั{}, // ะฒะฟัะฐะฒะปััั ะผะพะทะณะธ ะฝะฐ ะผะตััะพ
rus_verbs:ะฒัะตะผะตะฝะธัั{}, // ะฒัะตะผะตะฝะธัั ั ะฒัั
ะพะดะพะผ ะฝะฐ ะฟะตะฝัะธั
rus_verbs:ะฒััะฑะฐัั{}, // ะฒััะฑะฐัั ะฝะฐ ะฟะพะปะฝัั ะผะพัะฝะพััั
rus_verbs:ะฒััะฑะธัั{}, // ะฒััะฑะธัั ะฝะฐ ะฟะพะปะฝัั ะผะพัะฝะพััั
rus_verbs:ะฒััะฑะธัััั{}, // ะฒััะฑะธัััั ะฝะฐ ะฟะพะปะฝัั ะผะพัะฝะพััั
rus_verbs:ะฒััะฒะฐัััั{}, // ะฒััะฒะฐัััั ะฝะฐ ัะพะฑัะฐะฝะธะต
rus_verbs:ะฒัะบะฐัะฐะฑะบะฐัััั{}, // ะฒัะบะฐัะฐะฑะบะฐัััั ะฝะฐ ัััั
rus_verbs:ะฒัะบะฐัะฐะฑะบะธะฒะฐัััั{}, // ะฒัะบะฐัะฐะฑะบะธะฒะฐัััั ะฝะฐ ัััั
rus_verbs:ะฒัะบะพัะธัั{}, // ะฒัะบะพัะธัั ะฝะฐ ะฝะพะณะธ
rus_verbs:ะฒัะฟะปัะฒะฐัั{}, // ะฒัะฟะปัะฒะฐัั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััั ะฒะพะดั
rus_verbs:ะฒัะฟะปััั{}, // ะฒัะฟะปััั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััั ะฒะพะดั
rus_verbs:ะฒัะฟััะณะธะฒะฐัั{}, // ะฒัะฟััะณะธะฒะฐัั ะฝะฐ ะฟะปะฐััะพัะผั
rus_verbs:ะฒัะฟััะณะฝััั{}, // ะฒัะฟััะณะฝััั ะฝะฐ ะฟะปะฐััะพัะผั
rus_verbs:ะฒััะฐัั{}, // ะฒััะฐัั ะฝะฐ ะทะฐัะธัั ัะตััะธ ะธ ะดะพััะพะธะฝััะฒะฐ
rus_verbs:ะฒัะพัะณะฐัััั{}, // ะฒัะพัะณะฐัััั ะฝะฐ ััะถัั ัะตััะธัะพัะธั
rus_verbs:ะฒัะพัะณะฝััััั{}, // ะฒัะพัะณะฝััััั ะฝะฐ ััะถัั ัะตััะธัะพัะธั
rus_verbs:ะฒัะตะทะถะฐัั{}, // ะฒัะตะทะถะฐัั ะฝะฐ ะฟะฐะฝะดัั
rus_verbs:ะฝะฐัะฑะตะดะฝะธัะฐัั{}, // ะฝะฐัะฑะตะดะฝะธัะฐัั ะฝะฐ ัะพัะตะดะฐ ะฟะพ ะฟะฐััะต
rus_verbs:ะฒัะฑะปะตะฒะฐัั{}, // ะฒัะฑะปะตะฒะฐัั ะทะฐะฒััะฐะบ ะฝะฐ ะฟะพะป
rus_verbs:ะฒัะฑะปะตะฒะฐัััั{}, // ะฒัะฑะปะตะฒะฐัััั ะฝะฐ ะฟะพะป
rus_verbs:ะฒัะฑะปะตะฒัะฒะฐัั{}, // ะฒัะฑะปะตะฒัะฒะฐัั ะทะฐะฒััะฐะบ ะฝะฐ ะฟะพะป
rus_verbs:ะฒัะฑะปะตะฒัะฒะฐัััั{}, // ะฒัะฑะปะตะฒัะฒะฐัััั ะฝะฐ ะฟะพะป
rus_verbs:ะฒัะฒะตะทัะธ{}, // ะฒัะฒะตะทัะธ ะผััะพั ะฝะฐ ัะฒะฐะปะบั
rus_verbs:ะฒัะฒะตัะธัั{}, // ะฒัะฒะตัะธัั ะฑะตะปัะต ะฝะฐ ะฟัะพัััะบั
rus_verbs:ะฒัะฒะตััะธ{}, // ะฒัะฒะตััะธ ัะพะฑะฐะบั ะฝะฐ ะฟัะพะณัะปะบั
rus_verbs:ะฒัะฒะตัะธะฒะฐัั{}, // ะฒัะฒะตัะธะฒะฐัั ะฑะตะปัะต ะฝะฐ ะฒะตัะตะฒะบั
rus_verbs:ะฒัะฒะพะทะธัั{}, // ะฒัะฒะพะทะธัั ะดะตัะตะน ะฝะฐ ะฟัะธัะพะดั
rus_verbs:ะฒัะทัะฒะฐัั{}, // ะะฐัะฐะปัะฝะธะบ ะฒัะทัะฒะฐะตั ะฝะฐ ะบะพะฒะตั
rus_verbs:ะฒัะนัะธ{}, // ะฒัะนัะธ ะฝะฐ ัะฒะพะฑะพะดั
rus_verbs:ะฒัะบะปะฐะดัะฒะฐัั{}, // ะฒัะบะปะฐะดัะฒะฐัั ะฝะฐ ะฒัะตะพะฑัะตะต ะพะฑะพะทัะตะฝะธะต
rus_verbs:ะฒัะบะปะฐะดัะฒะฐัััั{}, // ะฒัะบะปะฐะดัะฒะฐัััั ะฝะฐ ะฒัะตะพะฑัะตะต ะพะฑะพะทัะตะฝะธะต
rus_verbs:ะฒัะปะธะฒะฐัั{}, // ะฒัะปะธะฒะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะปะธะฒะฐัััั{}, // ะฒัะปะธะฒะฐัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะปะธัั{}, // ะฒัะปะธัั ะถะธะดะบะพััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะปะธัััั{}, // ะขะพะฟะปะธะฒะพ ะฒัะปะธะปะพัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะปะพะถะธัั{}, // ะฒัะปะพะถะธัั ะฝะฐ ะฑะตัะตะณ
rus_verbs:ะฒัะผะตะฝะธะฒะฐัั{}, // ะฒัะผะตะฝะธะฒะฐัั ะทะพะปะพัะพ ะฝะฐ ั
ะปะตะฑ
rus_verbs:ะฒัะผะตะฝะธะฒะฐัััั{}, // ะะพะปะพัะพ ะฒัะผะตะฝะธะฒะฐะตััั ะฝะฐ ั
ะปะตะฑ
rus_verbs:ะฒัะผะตะฝััั{}, // ะฒัะผะตะฝััั ะทะพะปะพัะพ ะฝะฐ ั
ะปะตะฑ
rus_verbs:ะฒัะฟะฐะดะฐัั{}, // ัะฝะตะณ ะฒัะฟะฐะดะฐะตั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะฟะปะตะฒัะฒะฐัั{}, // ะฒัะฟะปะตะฒัะฒะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะฟะปะตะฒัะฒะฐัััั{}, // ะฒัะฟะปะตะฒัะฒะฐัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะฟะปะตัะบะฐัั{}, // ะฒัะฟะปะตัะบะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะฟะปะตัะบะฐัััั{}, // ะฒัะฟะปะตัะบะฐัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะฟะปะตัะบะธะฒะฐัั{}, // ะฒัะฟะปะตัะบะธะฒะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะฟะปะตัะบะธะฒะฐัััั{}, // ะฒัะฟะปะตัะบะธะฒะฐัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัะฟะปัะฒะฐัั{}, // ะฒัะฟะปัะฒะฐัั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััั
rus_verbs:ะฒัะฟะปััั{}, // ะฒัะฟะปััั ะฝะฐ ะฟะพะฒะตัั
ะฝะพััั
rus_verbs:ะฒัะฟะปัะฝััั{}, // ะฒัะฟะปัะฝััั ะฝะฐ ะฟะพะป
rus_verbs:ะฒัะฟะพะปะทะฐัั{}, // ะฒัะฟะพะปะทะฐัั ะฝะฐ ัะฒะตะถะธะน ะฒะพะทะดัั
rus_verbs:ะฒัะฟัะพัะธัััั{}, // ะฒัะฟัะพัะธัััั ะฝะฐ ัะปะธัั
rus_verbs:ะฒัะฟััะณะธะฒะฐัั{}, // ะฒัะฟััะณะธะฒะฐัั ะฝะฐ ัะฒะพะฑะพะดั
rus_verbs:ะฒัะฟััะณะฝััั{}, // ะฒัะฟััะณะฝััั ะฝะฐ ะฟะตััะพะฝ
rus_verbs:ะฒัะฟััะบะฐัั{}, // ะฒัะฟััะบะฐัั ะฝะฐ ัะฒะพะฑะพะดั
rus_verbs:ะฒัะฟัััะธัั{}, // ะฒัะฟัััะธัั ะฝะฐ ัะฒะพะฑะพะดั
rus_verbs:ะฒัะฟััะธะฒะฐัั{}, // ะฒัะฟััะธะฒะฐัั ะฝะฐ ะบะพะณะพ-ัะพ ะณะปะฐะทะฐ
rus_verbs:ะฒัะฟััะธะฒะฐัััั{}, // ะณะปะฐะทะฐ ะฒัะฟััะธะฒะฐัััั ะฝะฐ ะบะพะณะพ-ัะพ
rus_verbs:ะฒัะฟััะธัั{}, // ะฒัะฟััะธัั ะณะปะฐะทะฐ ะฝะฐ ะบะพะณะพ-ัะพ
rus_verbs:ะฒัะฟััะธัััั{}, // ะฒัะฟััะธัััั ะฝะฐ ะบะพะณะพ-ัะพ
rus_verbs:ะฒััะพะฝะธัั{}, // ะฒััะพะฝะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒััะฐะดะธัั{}, // ะฒััะฐะดะธัั ะฝะฐ ะฑะตัะตะณ
rus_verbs:ะฒััะฐะดะธัััั{}, // ะฒััะฐะดะธัััั ะฝะฐ ะฑะตัะตะณ
rus_verbs:ะฒััะฐะถะธะฒะฐัััั{}, // ะฒััะฐะถะธะฒะฐัััั ะฝะฐ ะพัััะพะฒ
rus_verbs:ะฒััะบะฐะปัะทัะฒะฐัั{}, // ะฒััะบะฐะปัะทัะฒะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒััะบะพัะธัั{}, // ะฒััะบะพัะธัั ะฝะฐ ััะตะฝั
rus_verbs:ะฒััะผะพัะบะฐัััั{}, // ะฒััะผะพัะบะฐัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒััะผะพัะบะฝััััั{}, // ะฒััะผะพัะบะฝััััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัััะฐะฒะธัั{}, // ะฒัััะฐะฒะธัั ะฝะฐ ะฒัะตะพะฑัะตะต ะพะฑะพะทัะตะฝะธะต
rus_verbs:ะฒัััะฐะฒะธัััั{}, // ะฒัััะฐะฒะธัััั ะฝะฐ ะฒัะตะพะฑัะตะต ะพะฑะพะทัะตะฝะธะต
rus_verbs:ะฒัััะฐะฒะปััั{}, // ะฒัััะฐะฒะปััั ะฝะฐ ะฒัะตะพะฑัะตะต ะพะฑะพะทัะตะฝะธะต
rus_verbs:ะฒัััะฐะฒะปััััั{}, // ะฒัััะฐะฒะปััััั ะฝะฐ ะฒัะตะพะฑัะตะต ะพะฑะพะทัะตะฝะธะต
ะธะฝัะธะฝะธัะธะฒ:ะฒัััะฟะฐัั{ะฒะธะด:ัะพะฒะตัั}, // ะฒัััะฟะฐัั ะฝะฐ ะทะตะผะปั
ะธะฝัะธะฝะธัะธะฒ:ะฒัััะฟะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฒัััะฟะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฒัััะฟะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ะฒัััะฟะฐะฒ{},
ะดะตะตะฟัะธัะฐััะธะต:ะฒัััะฟะฐั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒัััะฟะฐะฒัะธะน{ะฒะธะด:ัะพะฒะตัั},
//++ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒัััะฟะฐะฒัะธะน{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒัััะฟะฐััะธะน{ะฒะธะด:ะฝะตัะพะฒะตัั},
rus_verbs:ะฒัััะฟะฐัััั{}, // ะฒัััะฟะฐัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒััะฐัะฐัะธะฒะฐัั{}, // ะฒััะฐัะฐัะธะฒะฐัั ะณะปะฐะทะฐ ะฝะฐ ะผะตะดะฒะตะดั
rus_verbs:ะฒััะฐัะฐัะธะฒะฐัััั{}, // ะฒััะฐัะฐัะธะฒะฐัััั ะฝะฐ ะผะตะดะฒะตะดั
rus_verbs:ะฒััะฐัะฐัะธัั{}, // ะฒััะฐัะฐัะธัั ะณะปะฐะทะฐ ะฝะฐ ะผะตะดะฒะตะดั
rus_verbs:ะฒััะฐัะฐัะธัััั{}, // ะฒััะฐัะฐัะธัััั ะฝะฐ ะผะตะดะฒะตะดั
rus_verbs:ะฒััะตะบะฐัั{}, // ะฒััะตะบะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒััะตัั{}, // ะฒััะตัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒัััะธะฒะฐัััั{}, // ะฒัััะธะฒะฐัััั ะฝะฐ ะบะพะณะพ-ัะพ
rus_verbs:ะฒัััะธัััั{}, // ะฒัััะธัััั ะฝะฐ ะบะพะณะพ-ัะพ
rus_verbs:ะฟะพัะผะพััะตัั{}, // ะฟะพัะผะพััะตัั ะฝะฐ ัะบัะฐะฝ
rus_verbs:ะฝะฐัะธัั{}, // ะฝะฐัะธัั ััะพ-ัะพ ะฝะฐ ะพะดะตะถะดั
rus_verbs:ะฟัะธะดัะธ{}, // ะฟัะธะดัะธ ะฝะฐ ะฟะพะผะพัั ะบะพะผั-ัะพ
ะธะฝัะธะฝะธัะธะฒ:ะฟัะธะนัะธ{}, // ะฟัะธะนัะธ ะฝะฐ ะฟะพะผะพัั ะบะพะผั-ัะพ
ะณะปะฐะณะพะป:ะฟัะธะนัะธ{},
ะดะตะตะฟัะธัะฐััะธะต:ะฟัะธะดั{}, // ะัะธะดั ะฝะฐ ะฒะพะบะทะฐะป, ะพะฝ ะฟะพัะฟะตัะฝะพ ะฒะทัะป ะฑะธะปะตัั.
rus_verbs:ะฟะพะดะฝััั{}, // ะฟะพะดะฝััั ะฝะฐ ะฒะตััะธะฝั
rus_verbs:ัะพะณะปะฐัะธัััั{}, // ัะพะณะปะฐัะธัััั ะฝะฐ ะฝะธััั
rus_verbs:ะฟะพัะปะฐัั{}, // ะฟะพัะปะฐัั ะฝะฐ ััะพะฝั
rus_verbs:ัะปะฐัั{}, // ัะปะฐัั ะฝะฐ ััะพะฝั
rus_verbs:ะฝะฐะดะตััััั{}, // ะฝะฐะดะตััััั ะฝะฐ ะปัััะตะต
rus_verbs:ะบัะธะบะฝััั{}, // ะบัะธะบะฝััั ะฝะฐ ัะฐะปัะฝะพะฒ
rus_verbs:ะฟัะพะนัะธ{}, // ะฟัะพะนัะธ ะฝะฐ ะฟะปัะถ
rus_verbs:ะฟัะธัะปะฐัั{}, // ะฟัะธัะปะฐัั ะฝะฐ ัะบัะฟะตััะธะทั
rus_verbs:ะถะธัั{}, // ะถะธัั ะฝะฐ ะฟะพะดะฐัะบะธ
rus_verbs:ััะฐะฝะพะฒะธัััั{}, // ััะฐะฝะพะฒะธัััั ะฝะฐ ะฝะพะณะธ
rus_verbs:ะฝะฐัะปะฐัั{}, // ะฝะฐัะปะฐัั ะฝะฐ ะบะพะณะพ-ัะพ
rus_verbs:ะฟัะธะฝััั{}, // ะฟัะธะฝััั ะฝะฐ ะทะฐะผะตัะบั
rus_verbs:ัะพะฑะธัะฐัััั{}, // ัะพะฑะธัะฐัััั ะฝะฐ ัะบะทะฐะผะตะฝ
rus_verbs:ะพััะฐะฒะธัั{}, // ะพััะฐะฒะธัั ะฝะฐ ะฒััะบะธะน ัะปััะฐะน
rus_verbs:ะทะฒะฐัั{}, // ะทะฒะฐัั ะฝะฐ ะฟะพะผะพัั
rus_verbs:ะฝะฐะฟัะฐะฒะธัััั{}, // ะฝะฐะฟัะฐะฒะธัััั ะฝะฐ ะฟัะพะณัะปะบั
rus_verbs:ะพัะฒะตัะฐัั{}, // ะพัะฒะตัะฐัั ะฝะฐ ะทะฒะพะฝะบะธ
rus_verbs:ะพัะฟัะฐะฒะธัััั{}, // ะพัะฟัะฐะฒะธัััั ะฝะฐ ะฟัะพะณัะปะบั
rus_verbs:ะฟะพััะฐะฒะธัั{}, // ะฟะพััะฐะฒะธัั ะฝะฐ ะฟะพะป
rus_verbs:ะพะฑะตัะฝััััั{}, // ะพะฑะตัะฝััััั ะฝะฐ ะทะพะฒ
rus_verbs:ะพัะพะทะฒะฐัััั{}, // ะพัะพะทะฒะฐัััั ะฝะฐ ะฟัะพััะฑั
rus_verbs:ะทะฐะบัะธัะฐัั{}, // ะทะฐะบัะธัะฐัั ะฝะฐ ัะพะฑะฐะบั
rus_verbs:ะพะฟัััะธัั{}, // ะพะฟัััะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฟัะธะฝะตััะธ{}, // ะฟัะธะฝะตััะธ ะฝะฐ ะฟะปัะถ ัะฒะพะน ะถะตะทะปะพะฝะณ
rus_verbs:ัะบะฐะทะฐัั{}, // ัะบะฐะทะฐัั ะฝะฐ ะดะฒะตัั
rus_verbs:ั
ะพะดะธัั{}, // ั
ะพะดะธัั ะฝะฐ ะทะฐะฝััะธั
rus_verbs:ัััะฐะฒะธัััั{}, // ัััะฐะฒะธัััั ะฝะฐ ะปะธััะพะบ
rus_verbs:ะฟัะธั
ะพะดะธัั{}, // ะฟัะธั
ะพะดะธัั ะฝะฐ ัะบะทะฐะผะตะฝ
rus_verbs:ะผะฐั
ะฝััั{}, // ะผะฐั
ะฝััั ะฝะฐ ะฟะปัะถ
rus_verbs:ัะฒะธัััั{}, // ัะฒะธัััั ะฝะฐ ะดะพะฟัะพั
rus_verbs:ะพะณะปัะฝััััั{}, // ะพะณะปัะฝััััั ะฝะฐ ะดะพัะพะณั
rus_verbs:ัะตั
ะฐัั{}, // ัะตั
ะฐัั ะฝะฐ ะทะฐัะฐะฑะพัะบะธ
rus_verbs:ะฟะพะฒะตััะธ{}, // ะฟะพะฒะตััะธ ะฝะฐ ััััะผ
rus_verbs:ะพะฟัััะธัััั{}, // ะพะฟัััะธัััั ะฝะฐ ะบะพะปะตะฝะธ
//rus_verbs:ะฟะตัะตะดะฐัั{}, // ะฟะตัะตะดะฐัั ะฝะฐ ะฟัะพะฒะตัะบั
rus_verbs:ะฟะพะฑะตะถะฐัั{}, // ะฟะพะฑะตะถะฐัั ะฝะฐ ะทะฐะฝััะธั
rus_verbs:ะฟัะธะฑััั{}, // ะฟัะธะฑััั ะฝะฐ ะผะตััะพ ัะปัะถะฑั
rus_verbs:ะบัะธัะฐัั{}, // ะบัะธัะฐัั ะฝะฐ ะผะตะดะฒะตะดั
rus_verbs:ััะตัั{}, // ััะตัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะพะฑัะฐัะธัั{}, // ะพะฑัะฐัะธัั ะฝะฐ ัะตะฑั ะฒะฝะธะผะฐะฝะธะต
rus_verbs:ะฟะพะดะฐัั{}, // ะฟะพะดะฐัั ะฝะฐ ะฟัะพะฟะธัะฐะฝะธะต
rus_verbs:ะฟัะธะฒะตััะธ{}, // ะฟัะธะฒะตััะธ ะฝะฐ ััะตะผะบะธ
rus_verbs:ะธัะฟัััะฒะฐัั{}, // ะธัะฟัััะฒะฐัั ะฝะฐ ะถะธะฒะพัะฝัั
rus_verbs:ะฟะตัะตะฒะตััะธ{}, // ะฟะตัะตะฒะตััะธ ะฝะฐ ะถะตะฝั
rus_verbs:ะบัะฟะธัั{}, // ะบัะฟะธัั ะฝะฐ ะทะฐะตะผะฝัะต ะดะตะฝัะณะธ
rus_verbs:ัะพะฑัะฐัััั{}, // ัะพะฑัะฐัััั ะฝะฐ ะฒัััะตัั
rus_verbs:ะทะฐะณะปัะฝััั{}, // ะทะฐะณะปัะฝััั ะฝะฐ ะพะณะพะฝัะบ
rus_verbs:ะฝะฐะถะฐัั{}, // ะฝะฐะถะฐัั ะฝะฐ ัััะฐะณ
rus_verbs:ะฟะพัะฟะตัะธัั{}, // ะฟะพัะฟะตัะธัั ะฝะฐ ะฟัะฐะทะดะฝะธะบ
rus_verbs:ะฟะตัะตะนัะธ{}, // ะฟะตัะตะนัะธ ะฝะฐ ััััะบะธะน ัะทัะบ
rus_verbs:ะฟะพะฒะตัะธัั{}, // ะฟะพะฒะตัะธัั ะฝะฐ ัะตััะฝะพะต ัะปะพะฒะพ
rus_verbs:ะณะปัะฝััั{}, // ะณะปัะฝััั ะฝะฐ ะพะฑะปะพะถะบั
rus_verbs:ะทะฐะนัะธ{}, // ะทะฐะนัะธ ะฝะฐ ะพะณะพะฝัะบ
rus_verbs:ะฟัะพั
ะพะดะธัั{}, // ะฟัะพั
ะพะดะธัั ะฝะฐ ััะตะฝั
rus_verbs:ะณะปัะดะตัั{}, // ะณะปัะดะตัั ะฝะฐ ะฐะบััะธัั
//rus_verbs:ัะตัะธัััั{}, // ัะตัะธัััั ะฝะฐ ะฟััะถะพะบ
rus_verbs:ะฟัะธะณะปะฐัะธัั{}, // ะฟัะธะณะปะฐัะธัั ะฝะฐ ัะฐะฝะตั
rus_verbs:ะฟะพะทะฒะฐัั{}, // ะฟะพะทะฒะฐัั ะฝะฐ ัะบะทะฐะผะตะฝ
rus_verbs:ััะตััััั{}, // ััะตััััั ะฝะฐ ัััะป
rus_verbs:ะฟะพัััะฟะธัั{}, // ะฟะพัััะฟะธัั ะฝะฐ ะผะฐัะตะผะฐัะธัะตัะบะธะน ัะฐะบัะปััะตั
rus_verbs:ะปะตัั{}, // ะปะตัั ะฝะฐ ะถะธะฒะพั
rus_verbs:ะฟะพััะฝััััั{}, // ะฟะพััะฝััััั ะฝะฐ ัะณ
rus_verbs:ะฟัะธัะตััั{}, // ะฟัะธัะตััั ะฝะฐ ะบะพััะพัะบะธ
rus_verbs:ะฝะฐัััะฟะธัั{}, // ะฝะฐัััะฟะธัั ะฝะฐ ะทะผะตั
rus_verbs:ะทะฐะพัะฐัั{}, // ะทะฐะพัะฐัั ะฝะฐ ะฟะพะฟัะพัะฐะตะบ
rus_verbs:ะฝะฐะดะตัั{}, // ะฝะฐะดะตัั ะฝะฐ ะณะพะปะพะฒั
rus_verbs:ะฟะพะณะปัะดะตัั{}, // ะฟะพะณะปัะดะตัั ะฝะฐ ะดะตะฒัะพะฝะพะบ
rus_verbs:ะฟัะธะฝะธะผะฐัั{}, // ะฟัะธะฝะธะผะฐัั ะฝะฐ ะณะฐัะฐะฝัะธะนะฝะพะต ะพะฑัะปัะถะธะฒะฐะฝะธะต
rus_verbs:ะฟัะธะฒะตะทัะธ{}, // ะฟัะธะฒะตะทัะธ ะฝะฐ ะธัะฟััะฐะฝะธั
rus_verbs:ััั
ะฝััั{}, // ััั
ะฝััั ะฝะฐ ะฐััะฐะปัั
rus_verbs:ะฟััะบะฐัั{}, // ะฟััะบะฐัั ะฝะฐ ะบะพัะผ
rus_verbs:ะพัะฒะตััะธ{}, // ะพัะฒะตััะธ ะฝะฐ ะฟัะธัะผ
rus_verbs:ะพัะฟัะฐะฒะธัั{}, // ะพัะฟัะฐะฒะธัั ะฝะฐ ััะธะปะธะทะฐัะธั
rus_verbs:ะดะฒะธะณะฐัััั{}, // ะดะฒะธะณะฐัััั ะฝะฐ ะฒะพััะพะบ
rus_verbs:ะฝะตััะธ{}, // ะฝะตััะธ ะฝะฐ ะฟะปัะถ
rus_verbs:ะฟะฐะดะฐัั{}, // ะฟะฐะดะฐัั ะฝะฐ ััะบะธ
rus_verbs:ะพัะบะธะฝััััั{}, // ะพัะบะธะฝััััั ะฝะฐ ัะฟะธะฝะบั ะบัะตัะปะฐ
rus_verbs:ััะฒะบะฝััั{}, // ััะฒะบะฝััั ะฝะฐ ะดะตัะตะน
rus_verbs:ะฟะพะปััะฐัั{}, // ะฟะพะปััะฐัั ะฝะฐ ะฟัะพะถะธะฒะฐะฝะธะต
rus_verbs:ะฟะพะปะตะทัั{}, // ะฟะพะปะตะทัั ะฝะฐ ัะพะถะพะฝ
rus_verbs:ะฝะฐะฟัะฐะฒะธัั{}, // ะฝะฐะฟัะฐะฒะธัั ะฝะฐ ะดะพะพะฑัะปะตะดะพะฒะฐะฝะธะต
rus_verbs:ะฟัะธะฒะพะดะธัั{}, // ะฟัะธะฒะพะดะธัั ะฝะฐ ะฟัะพะฒะตัะบั
rus_verbs:ะฟะพััะตะฑะพะฒะฐัััั{}, // ะฟะพััะตะฑะพะฒะฐัััั ะฝะฐ ะทะฐะผะตะฝั
rus_verbs:ะบะธะฝััััั{}, // ะบะธะฝััััั ะฝะฐ ะฝะฐะฟะฐะดะฐะฒัะตะณะพ
rus_verbs:ััะธัััั{}, // ััะธัััั ะฝะฐ ัะพะบะฐัั
rus_verbs:ะฟัะธะฟะพะดะฝััั{}, // ะฟัะธะฟะพะดะฝััั ะฝะฐ ะพะดะธะฝ ะผะตัั
rus_verbs:ะฝะฐะปะธัั{}, // ะฝะฐะปะธัั ะฝะฐ ััะพะป
rus_verbs:ะธะณัะฐัั{}, // ะธะณัะฐัั ะฝะฐ ะดะตะฝัะณะธ
rus_verbs:ัะฐัััะธััะฒะฐัั{}, // ัะฐัััะธััะฒะฐัั ะฝะฐ ะฟะพะดะผะพะณั
rus_verbs:ัะตะฟะฝััั{}, // ัะตะฟะฝััั ะฝะฐ ัั
ะพ
rus_verbs:ัะฒััะฝััั{}, // ัะฒััะฝััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฟััะณะฝััั{}, // ะฟััะณะฝััั ะฝะฐ ะพะปะตะฝั
rus_verbs:ะฟัะตะดะปะฐะณะฐัั{}, // ะฟัะตะดะปะฐะณะฐัั ะฝะฐ ะฒัะฑะพั
rus_verbs:ัะฐะดะธัััั{}, // ัะฐะดะธัััั ะฝะฐ ัััะป
rus_verbs:ะปะธัั{}, // ะปะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะธัะฟััะฐัั{}, // ะธัะฟััะฐัั ะฝะฐ ะถะธะฒะพัะฝัั
rus_verbs:ัััะบะฝััั{}, // ัััะบะฝััั ะฝะฐ ะดะตัะตะฝััะฐ
rus_verbs:ะณะพะดะธัััั{}, // ะผััะพ ะณะพะดะธััั ะฝะฐ ัะฐัั
rus_verbs:ะฟัะพะฒะตัะธัั{}, // ะฟัะพะฒะตัะธัั ะฒััะบะฐะทัะฒะฐะฝะธะต ะฝะฐ ะธััะธะฝะฝะพััั
rus_verbs:ะพัะบะปะธะบะฝััััั{}, // ะพัะบะปะธะบะฝััััั ะฝะฐ ะฟัะธะทัะฒั
rus_verbs:ะฟะพะปะฐะณะฐัััั{}, // ะฟะพะปะฐะณะฐัััั ะฝะฐ ะธะฝััะธัะธั
rus_verbs:ะฟะพะบะพัะธัััั{}, // ะฟะพะบะพัะธัััั ะฝะฐ ัะพัะตะดะฐ
rus_verbs:ะฟะพะฒะตัะธัั{}, // ะฟะพะฒะตัะธัั ะฝะฐ ะณะฒะพะทะดั
ะธะฝัะธะฝะธัะธะฒ:ะฟะพั
ะพะดะธัั{ะฒะธะด:ัะพะฒะตัั}, // ะฟะพั
ะพะดะธัั ะฝะฐ ะทะฐะฝััะธั
ะณะปะฐะณะพะป:ะฟะพั
ะพะดะธัั{ะฒะธะด:ัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ะฟะพั
ะพะดะธะฒ{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะพั
ะพะดะธะฒัะธะน{},
rus_verbs:ะฟะพะผัะฐัััั{}, // ะฟะพะผัะฐัััั ะฝะฐ ัะบะทะฐะผะตะฝ
rus_verbs:ััะฐะฒะธัั{}, // ััะฐะฒะธัั ะฝะฐ ะบะพะฝััะพะปั
rus_verbs:ัะฒะฐะปะธัััั{}, // ัะฒะฐะปะธัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฒะฐะปะธัััั{}, // ะฒะฐะปะธัััั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฟะพะดะฐัะธัั{}, // ะฟะพะดะฐัะธัั ะฝะฐ ะดะตะฝั ัะพะถะดะตะฝัั
rus_verbs:ัะฑะตะถะฐัั{}, // ัะฑะตะถะฐัั ะฝะฐ ะฝะตะพะฑะธัะฐะตะผัะน ะพัััะพะฒ
rus_verbs:ัััะตะปััั{}, // ัััะตะปััั ะฝะฐ ะฟะพัะฐะถะตะฝะธะต
rus_verbs:ะพะฑัะฐัะฐัั{}, // ะพะฑัะฐัะฐัั ะฝะฐ ัะตะฑั ะฒะฝะธะผะฐะฝะธะต
rus_verbs:ะฝะฐัััะฟะฐัั{}, // ะฝะฐัััะฟะฐัั ะฝะฐ ัะต ะถะต ะณัะฐะฑะปะธ
rus_verbs:ัะฑัะพัะธัั{}, // ัะฑัะพัะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะพะฑะธะดะตัััั{}, // ะพะฑะธะดะตัััั ะฝะฐ ะดััะณะฐ
rus_verbs:ััััะพะธัััั{}, // ััััะพะธัััั ะฝะฐ ััะฐะถะธัะพะฒะบั
rus_verbs:ะฟะพะณััะทะธัััั{}, // ะฟะพะณััะทะธัััั ะฝะฐ ะฑะพะปัััั ะณะปัะฑะธะฝั
rus_verbs:ัะตัั{}, // ัะตัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะพัะฑัะพัะธัั{}, // ะพัะฑัะพัะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะผะตัะฐัั{}, // ะผะตัะฐัั ะฝะฐ ะดะฝะพ
rus_verbs:ะฟัััะธัั{}, // ะฟัััะธัั ะฝะฐ ะฟะตัะตะฟะปะฐะฒะบั
rus_verbs:ะฟัะพะถะธัั{}, // ะฟัะพะถะธัั ะฝะฐ ะฟะพัะพะฑะธะต
rus_verbs:ะฟะพะปะตัะตัั{}, // ะฟะพะปะตัะตัั ะฝะฐ ะบะพะฝัะธะฝะตะฝั
rus_verbs:ะฟัะพะฟัััะธัั{}, // ะฟัะพะฟัััะธัั ะฝะฐ ััะตะฝั
rus_verbs:ัะบะฐะทัะฒะฐัั{}, // ัะบะฐะทัะฒะฐัั ะฝะฐ ะพัะธะฑะบั
rus_verbs:ะฝะฐัะบะฝััััั{}, // ะฝะฐัะบะฝััััั ะฝะฐ ะบะปะฐะด
rus_verbs:ัะฒะฐะฝััั{}, // ัะฒะฐะฝััั ะฝะฐ ัะณ
rus_verbs:ัััะฟะฐัั{}, // ัััะฟะฐัั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะฟััะณะฝััั{}, // ัะฟััะณะฝััั ะฝะฐ ะฑะตัะตะณ
rus_verbs:ะทะฐั
ะพะดะธัั{}, // ะทะฐั
ะพะดะธัั ะฝะฐ ะพะณะพะฝัะบ
rus_verbs:ะฝััะฝััั{}, // ะฝััะฝััั ะฝะฐ ะณะปัะฑะธะฝั
rus_verbs:ัะฒะฐะฝััััั{}, // ัะฒะฐะฝััััั ะฝะฐ ัะฒะพะฑะพะดั
rus_verbs:ะฝะฐััะฝััั{}, // ะฝะฐััะฝััั ะฝะฐ ะณะพะปะพะฒั
rus_verbs:ะทะฐะฑัะฐัััั{}, // ะทะฐะฑัะฐัััั ะฝะฐ ััะพะป
rus_verbs:ะฟะพะผะฐั
ะฐัั{}, // ะฟะพะผะฐั
ะฐัั ะฝะฐ ะฟัะพัะฐะฝะธะต
rus_verbs:ัะพะดะตัะถะฐัั{}, // ัะพะดะตัะถะฐัั ะฝะฐ ัะฟะพะฝัะพััะบัั ะฟะพะผะพัั
rus_verbs:ะฟัะธะตะทะถะฐัั{}, // ะฟัะธะตะทะถะฐัั ะฝะฐ ะฟัะฐะทะดะฝะธะบะธ
rus_verbs:ะฟัะพะฝะธะบะฝััั{}, // ะฟัะพะฝะธะบะฝััั ะฝะฐ ัะตััะธัะพัะธั
rus_verbs:ะฟะพะดัะตั
ะฐัั{}, // ะฟะพะดัะตั
ะฐัั ะฝะฐ ะผะธัะธะฝะณ
rus_verbs:ััััะตะผะธัััั{}, // ััััะตะผะธัััั ะฝะฐ ะฒะพะปั
rus_verbs:ะฟะพัะฐะดะธัั{}, // ะฟะพัะฐะดะธัั ะฝะฐ ัััะป
rus_verbs:ัะธะฝััััั{}, // ัะธะฝััััั ะฝะฐ ะณะพะปะบะธะฟะตัะฐ
rus_verbs:ะฟะพะดะฒะธะณะฝััั{}, // ะฟะพะดะฒะธะณะฝััั ะฝะฐ ะฟะพะดะฒะธะณ
rus_verbs:ะพัะดะฐะฒะฐัั{}, // ะพัะดะฐะฒะฐัั ะฝะฐ ะฟะตัะตะฒะพัะฟะธัะฐะฝะธะต
rus_verbs:ะพัะปะพะถะธัั{}, // ะพัะปะพะถะธัั ะฝะฐ ัะตัะฝัะน ะดะตะฝั
rus_verbs:ัะฑะตะถะฐัั{}, // ัะฑะตะถะฐัั ะฝะฐ ัะฐะฝัั
rus_verbs:ะฟะพะดะฝะธะผะฐัั{}, // ะฟะพะดะฝะธะผะฐัั ะฝะฐ ะฒะตัั
ะฝะธะน ััะฐะถ
rus_verbs:ะฟะตัะตั
ะพะดะธัั{}, // ะฟะตัะตั
ะพะดะธัั ะฝะฐ ัะธััะพะฒะพะน ัะธะณะฝะฐะป
rus_verbs:ะพัะพัะปะฐัั{}, // ะพัะพัะปะฐัั ะฝะฐ ะฟะตัะตะฐััะตััะฐัะธั
rus_verbs:ะพัะพะดะฒะธะฝััั{}, // ะพัะพะดะฒะธะฝััั ะฝะฐ ะดััะณัั ะฟะพะปะพะฒะธะฝั ััะพะปะฐ
rus_verbs:ะฝะฐะทะฝะฐัะธัั{}, // ะฝะฐะทะฝะฐัะธัั ะฝะฐ ะดะพะปะถะฝะพััั
rus_verbs:ะพัะตััั{}, // ะพัะตััั ะฝะฐ ะดะฝะพ
rus_verbs:ัะพัะพะฟะธัััั{}, // ัะพัะพะฟะธัััั ะฝะฐ ัะบะทะฐะผะตะฝ
rus_verbs:ะผะตะฝััั{}, // ะผะตะฝััั ะฝะฐ ะตะดั
rus_verbs:ะดะพััะฐะฒะธัั{}, // ะดะพััะฐะฒะธัั ะฝะฐ ัะตััะพะน ััะฐะถ
rus_verbs:ะทะฐัะปะฐัั{}, // ะทะฐัะปะฐัั ะฝะฐ ะฟัะพะฒะตัะบั
rus_verbs:ะดััั{}, // ะดััั ะฝะฐ ะฒะพะดั
rus_verbs:ัะพัะปะฐัั{}, // ัะพัะปะฐัั ะฝะฐ ะบะฐัะพัะณั
rus_verbs:ะพััะฐะฝะฐะฒะปะธะฒะฐัััั{}, // ะพััะฐะฝะฐะฒะปะธะฒะฐัััั ะฝะฐ ะพัะดัั
rus_verbs:ัะดะฐะฒะฐัััั{}, // ัะดะฐะฒะฐัััั ะฝะฐ ะผะธะปะพััั ะฟะพะฑะตะดะธัะตะปั
rus_verbs:ัะพัะปะฐัััั{}, // ัะพัะปะฐัััั ะฝะฐ ะฟัะตะทัะผะฟัะธั ะฝะตะฒะธะฝะพะฒะฝะพััะธ
rus_verbs:ัะฐััะตัะดะธัััั{}, // ัะฐััะตัะดะธัััั ะฝะฐ ะดะพัั
rus_verbs:ะบะธะฝััั{}, // ะบะธะฝััั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะฐัะฟะพะปะพะถะธัััั{}, // ัะฐัะฟะพะปะพะถะธัััั ะฝะฐ ะฝะพัะปะตะณ
rus_verbs:ะพัะผะตะปะธัััั{}, // ะพัะผะตะปะธัััั ะฝะฐ ะฟะพะดะปะพะณ
rus_verbs:ัะตะฟัะฐัั{}, // ัะตะฟัะฐัั ะฝะฐ ััะบะพ
rus_verbs:ััะพะฝะธัั{}, // ััะพะฝะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะพัะบะธะฝััั{}, // ะพัะบะธะฝััั ะฝะฐ ัะฟะธะฝะบั ะบัะตัะปะฐ
rus_verbs:ะฟะตัะตะฝะตััะธ{}, // ะฟะตัะตะฝะตััะธ ะฝะฐ ัะฐะฑะพัะธะน ััะพะป
rus_verbs:ัะดะฐัััั{}, // ัะดะฐัััั ะฝะฐ ะผะธะปะพััั ะฟะพะฑะตะดะธัะตะปั
rus_verbs:ัะฒะตัะธัั{}, // ัะฒะตัะธัั ะฝะฐ ะดะพัะพะณั
rus_verbs:ะผัะฐัััั{}, // ะผัะฐัััั ะฝะฐ ะฑะฐะป
rus_verbs:ะฝะตััะธัั{}, // ะฝะตััะธัั ะฝะฐ ัะฒะธะดะฐะฝะธะต
rus_verbs:ะฟะพะณะปัะดัะฒะฐัั{}, // ะฟะพะณะปัะดัะฒะฐัั ะฝะฐ ัะบัะฐะฝ
rus_verbs:ะพัะฐัั{}, // ะพัะฐัั ะฝะฐ ะดะตัะตะน
rus_verbs:ัะปะพะถะธัั{}, // ัะปะพะถะธัั ะฝะฐ ะปะพะฟะฐัะบะธ
rus_verbs:ัะตัะฐัััั{}, // ัะตัะฐัััั ะฝะฐ ะฟะพัััะฟะพะบ
rus_verbs:ะฟะพะฟะฐะดะฐัั{}, // ะฟะพะฟะฐะดะฐัั ะฝะฐ ะบะฐัะฐะฝะดะฐั
rus_verbs:ัะฟะปัะฝััั{}, // ัะฟะปัะฝััั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะฝะธะผะฐัั{}, // ัะฝะธะผะฐัั ะฝะฐ ัะตะปะตัะพะฝ
rus_verbs:ะพะฟะพะทะดะฐัั{}, // ะพะฟะพะทะดะฐัั ะฝะฐ ัะฐะฑะพัั
rus_verbs:ะฟะพััะปะฐัั{}, // ะฟะพััะปะฐัั ะฝะฐ ะฟัะพะฒะตัะบั
rus_verbs:ะฟะพะณะฝะฐัั{}, // ะฟะพะณะฝะฐัั ะฝะฐ ะฟะฐััะฑะธัะต
rus_verbs:ะฟะพัััะฟะฐัั{}, // ะฟะพัััะฟะฐัั ะฝะฐ ะบะธะฑะตัะฝะตัะธัะตัะบะธะน ัะฐะบัะปััะตั
rus_verbs:ัะฟััะบะฐัััั{}, // ัะฟััะบะฐัััั ะฝะฐ ััะพะฒะตะฝั ะผะพัั
rus_verbs:ััะฐะดะธัั{}, // ััะฐะดะธัั ะฝะฐ ะดะธะฒะฐะฝ
rus_verbs:ะฟัะพะธะณัะฐัั{}, // ะฟัะพะธะณัะฐัั ะฝะฐ ัะฟะพั
rus_verbs:ะฟัะธะปะตัะตัั{}, // ะฟัะธะปะตัะตัั ะฝะฐ ัะตััะธะฒะฐะปั
rus_verbs:ะฟะพะฒะฐะปะธัััั{}, // ะฟะพะฒะฐะปะธัััั ะฝะฐ ัะฟะธะฝั
rus_verbs:ะพะณััะทะฝััััั{}, // ะกะพะฑะฐะบะฐ ะพะณััะทะฝัะปะฐัั ะฝะฐ ั
ะพะทัะธะฝะฐ
rus_verbs:ะทะฐะดะฐะฒะฐัั{}, // ะทะฐะดะฐะฒะฐัั ะฝะฐ ะฒัั
ะพะดะฝัะต
rus_verbs:ะทะฐะฟะฐััั{}, // ะทะฐะฟะฐััั ะฝะฐ ะดะตะฒะพัะบั
rus_verbs:ะปะตะทัั{}, // ะปะตะทัั ะฝะฐ ะทะฐะฑะพั
rus_verbs:ะฟะพัะฐัะธัั{}, // ะฟะพัะฐัะธัั ะฝะฐ ะฒัะฑะพัั
rus_verbs:ะฝะฐะฟัะฐะฒะปััััั{}, // ะฝะฐะฟัะฐะฒะปััััั ะฝะฐ ัะบะทะฐะผะตะฝ
rus_verbs:ะพะฟัะตะดะตะปััั{}, // ะพะฟัะตะดะตะปััั ะฝะฐ ะฒะบัั
rus_verbs:ะฟะพะฟะพะปะทัะธ{}, // ะฟะพะฟะพะปะทัะธ ะฝะฐ ััะตะฝั
rus_verbs:ะฟะพะฟะปััั{}, // ะฟะพะฟะปััั ะฝะฐ ะฑะตัะตะณ
rus_verbs:ะทะฐะปะตะทัั{}, // ะทะฐะปะตะทัั ะฝะฐ ัะฑะปะพะฝั
rus_verbs:ัะดะฐัั{}, // ัะดะฐัั ะฝะฐ ะผััะพะบะพะผะฑะธะฝะฐั
rus_verbs:ะฟัะธะทะตะผะปะธัััั{}, // ะฟัะธะทะตะผะปะธัััั ะฝะฐ ะดะพัะพะณั
rus_verbs:ะปะฐััั{}, // ะปะฐััั ะฝะฐ ะฟัะพั
ะพะถะธั
rus_verbs:ะฟะตัะตะฒะตัะฝััั{}, // ะฟะตัะตะฒะตัะฝััั ะฝะฐ ะฑะพะบ
rus_verbs:ะปะพะฒะธัั{}, // ะปะพะฒะธัั ะฝะฐ ะถะธะฒัะฐ
rus_verbs:ะพัะฝะตััะธ{}, // ะพัะฝะตััะธ ะถะธะฒะพัะฝะพะต ะฝะฐ ั
ะธัััะณะธัะตัะบะธะน ััะพะป
rus_verbs:ะฟะปัะฝััั{}, // ะฟะปัะฝััั ะฝะฐ ััะปะพะฒะฝะพััะธ
rus_verbs:ะฟะตัะตะดะฐะฒะฐัั{}, // ะฟะตัะตะดะฐะฒะฐัั ะฝะฐ ะฟัะพะฒะตัะบั
rus_verbs:ะฝะฐะฝััั{}, // ะะพัั ะฝะฐะฝัะป ะฝะฐ ัะฐะฑะพัั ะตัะต ะฝะตัะบะพะปัะบะพ ัะตะปะพะฒะตะบ
rus_verbs:ัะฐะทะพะทะปะธัััั{}, // ะะฐะฟะฐ ัะฐะทะพะทะปะธะปัั ะฝะฐ ััะฝะฐ ะธะท-ะทะฐ ะฟะปะพั
ะธั
ะพัะตะฝะพะบ ะฟะพ ะผะฐัะตะผะฐัะธะบะต
ะธะฝัะธะฝะธัะธะฒ:ัะฐัััะฟะฐัััั{ะฒะธะด:ะฝะตัะพะฒะตัั}, // ัะฐัััะฟะฐัััั ะฝะฐ ะผะตะปะบะธะต ะดะตัะฐะปะธ
ะธะฝัะธะฝะธัะธะฒ:ัะฐัััะฟะฐัััั{ะฒะธะด:ัะพะฒะตัั},
ะณะปะฐะณะพะป:ัะฐัััะฟะฐัััั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ัะฐัััะฟะฐัััั{ะฒะธะด:ัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ัะฐัััะฟะฐะฒัะธัั{},
ะดะตะตะฟัะธัะฐััะธะต:ัะฐัััะฟะฐััั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฐัััะฟะฐะฒัะธะนัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฐัััะฟะฐะฒัะธะนัั{ะฒะธะด:ัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฐัััะฟะฐััะธะนัั{},
rus_verbs:ะทะฐัััะฐัั{}, // ะะตะดะฒะตะดะธัะฐ ะทะฐัััะฐะปะฐ ะฝะฐ ะผะตะดะฒะตะถะพะฝะบะฐ
rus_verbs:ะฟัะธะทะฒะฐัั{}, // ะฟัะธะทะฒะฐัั ะฝะฐ ัะฑะพัั
rus_verbs:ัะฒะตะทัะธ{}, // ัะฒะตะทัะธ ะฝะฐ ะดะฐัั
rus_verbs:ัะพะดะตัะถะฐัััั{}, // ัะพะดะตัะถะฐัััั ะฝะฐ ะฟะพะถะตััะฒะพะฒะฐะฝะธั
rus_verbs:ะฝะฐะฒะตััะธ{}, // ะฝะฐะฒะตััะธ ะฝะฐ ัะบะพะฟะปะตะฝะธะต ัะตะปะตัะบะพะฟ
rus_verbs:ะพัะฟัะฐะฒะปััััั{}, // ะพัะฟัะฐะฒะปััััั ะฝะฐ ััะธะปะธะทะฐัะธั
rus_verbs:ัะปะตัััั{}, // ัะปะตัััั ะฝะฐ ะถะธะฒะพัะธะบ
rus_verbs:ะฝะฐะปะตัะตัั{}, // ะฝะฐะปะตัะตัั ะฝะฐ ะฟัะตะฟััััะฒะธะต
rus_verbs:ะฟะตัะตะฒะตัะฝััััั{}, // ะฟะตัะตะฒะตัะฝััััั ะฝะฐ ัะฟะธะฝั
rus_verbs:ัะปะตัะตัั{}, // ัะปะตัะตัั ะฝะฐ ัะพะดะธะฝั
rus_verbs:ะปะพะถะธัััั{}, // ะปะพะถะธัััั ะฝะฐ ะฑะพะบ
rus_verbs:ะบะปะฐััั{}, // ะบะปะฐััั ะฝะฐ ะผะตััะพ
rus_verbs:ะพััะตะฐะณะธัะพะฒะฐัั{}, // ะพััะตะฐะณะธัะพะฒะฐัั ะฝะฐ ะฒััััะฟะปะตะฝะธะต
rus_verbs:ะดะพััะฐะฒะปััั{}, // ะดะพััะฐะฒะปััั ะฝะฐ ะดะพะผ
rus_verbs:ะพัะฝััั{}, // ะพัะฝััั ะฝะฐ ะฑะปะฐะณะพ ะฟัะฐะฒััะตะน ะฒะตัั
ััะบะธ
rus_verbs:ัััะฟะธัั{}, // ัััะฟะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ัะฒะพะดะธัั{}, // ัะฒะพะดะธัั ะฝะฐ ะบะพะฝัะตัั ะทะฝะฐะผะตะฝะธัะพะน ัะพะบ-ะณััะฟะฟั
rus_verbs:ัะฝะตััะธ{}, // ัะฝะตััะธ ะฝะฐ ัะฐะฑะพัั
rus_verbs:ัั
ะพะดะธัั{}, // ัั
ะพะดะธัั ะฝะฐ ะบะพะฝัะตัั
rus_verbs:ะฟะพััะฐัะธัั{}, // ะฟะพััะฐัะธัั ะฝะฐ ะบะพัะผ ะธ ะฝะฐะฟะพะปะฝะธัะตะปั ะดะปั ััะฐะปะตัะฐ ะฒัะต ะดะตะฝัะณะธ
rus_verbs:ัะพัะบะพัะธัั{}, // ัะพัะบะพัะธัั ะฝะฐ ะทะตะผะปั
rus_verbs:ะฟะพะถะฐะปะพะฒะฐัััั{}, // ะฟะพะถะฐะปะพะฒะฐัััั ะฝะฐ ัะพัะตะดะตะน
rus_verbs:ัะฐัะธัั{}, // ัะฐัะธัั ะฝะฐ ะทะฐะผะตะฝั
rus_verbs:ะทะฐะผะฐั
ะฐัั{}, // ะทะฐะผะฐั
ะฐัั ััะบะฐะผะธ ะฝะฐ ะฟะฐัะตะฝัะบะฐ
rus_verbs:ะทะฐะณะปัะดัะฒะฐัั{}, // ะทะฐะณะปัะดัะฒะฐัั ะฝะฐ ะพะฑะตะด
rus_verbs:ัะพะณะปะฐัะฐัััั{}, // ัะพะณะปะฐัะฐัััั ะฝะฐ ัะฐะฒะฝัะน ะพะฑะผะตะฝ
rus_verbs:ะฟะปัั
ะฝััััั{}, // ะฟะปัั
ะฝััััั ะฝะฐ ะผัะณะบะธะน ะฟััะธะบ
rus_verbs:ัะฒะตััะธ{}, // ัะฒะตััะธ ะฝะฐ ะพัะผะพัั
rus_verbs:ััะฟะตะฒะฐัั{}, // ััะฟะตะฒะฐัั ะฝะฐ ะบะพะฝััะพะปัะฝัั ัะฐะฑะพัั
rus_verbs:ะพะฟัะพะบะธะฝััั{}, // ะพะฟัะพะบะธะฝััั ะฝะฐ ัะตะฑั
rus_verbs:ะฟะพะดะฐะฒะฐัั{}, // ะฟะพะดะฐะฒะฐัั ะฝะฐ ะฐะฟะตะปะปััะธั
rus_verbs:ะฟัะธะฑะตะถะฐัั{}, // ะฟัะธะฑะตะถะฐัั ะฝะฐ ะฒะพะบะทะฐะป
rus_verbs:ะพััะฒััะฝััั{}, // ะพััะฒััะฝััั ะฝะฐ ะทะฐะผะปั
rus_verbs:ะฟัะธะฒะปะตะบะฐัั{}, // ะฟัะธะฒะปะตะบะฐัั ะฝะฐ ัะฒะพั ััะพัะพะฝั
rus_verbs:ะพะฟะตัะตัััั{}, // ะพะฟะตัะตัััั ะฝะฐ ะฟะฐะปะบั
rus_verbs:ะฟะตัะตะฑัะฐัััั{}, // ะฟะตัะตะฑัะฐัััั ะฝะฐ ะผะฐะปะตะฝัะบะธะน ะพัััะพะฒะพะบ
rus_verbs:ัะณะพะฒะพัะธัั{}, // ัะณะพะฒะพัะธัั ะฝะฐ ะฝะพะฒัะต ััะฐัั
rus_verbs:ะณัะปััั{}, // ะณัะปััั ะฝะฐ ัะฟะพะฝัะพััะบะธะต ะดะตะฝัะณะธ
rus_verbs:ะฟะตัะตะฒะพะดะธัั{}, // ะฟะตัะตะฒะพะดะธัั ะฝะฐ ะดััะณะพะน ะฟััั
rus_verbs:ะทะฐะบะพะปะตะฑะฐัััั{}, // ะทะฐะบะพะปะตะฑะฐัััั ะฝะฐ ะพะดะธะฝ ะผะธะณ
rus_verbs:ะทะฐัะตะฟัะฐัั{}, // ะทะฐัะตะฟัะฐัั ะฝะฐ ััะบะพ
rus_verbs:ะฟัะธะฒััะฐัั{}, // ะฟัะธะฒััะฐัั ะฝะฐ ััะฟะพัะบะธ
rus_verbs:ั
ะปัะฝััั{}, // ั
ะปัะฝััั ะฝะฐ ะฑะตัะตะณ
rus_verbs:ะฝะฐะฑัะพัะธัััั{}, // ะฝะฐะฑัะพัะธัััั ะฝะฐ ะตะดั
rus_verbs:ะฝะฐะฟะฐััั{}, // ะฟะพะฒััะฐะฝัั, ะฝะฐะฟะฐะฒัะธะต ะฝะฐ ะบะพะฝะฒะพะน
rus_verbs:ัะฑัะฐัั{}, // ะบะฝะธะณะฐ, ัะฑัะฐะฝะฝะฐั ะฝะฐ ะฟะพะปะบั
rus_verbs:ะฟะพะฟะฐััั{}, // ะฟััะตัะตััะฒะตะฝะฝะธะบะธ, ะฟะพะฟะฐะฒัะธะต ะฝะฐ ะฝะธัะตะนะฝัั ัะตััะธัะพัะธั
rus_verbs:ะทะฐัะผะฐััะธะฒะฐัััั{}, // ะทะฐัะผะฐััะธะฒะฐัััั ะฝะฐ ะดะตะฒัะพะฝะพะบ
rus_verbs:ะทะฐััะตะณะฝััััั{}, // ะทะฐััะตะณะฝััััั ะฝะฐ ะฒัะต ะฟัะณะพะฒะธัั
rus_verbs:ะฟัะพะฒะตัะธัััั{}, // ะฟัะพะฒะตัะธัััั ะฝะฐ ะทะฐะฑะพะปะตะฒะฐะฝะธั
rus_verbs:ะฟัะพะฒะตัััััั{}, // ะฟัะพะฒะตัััััั ะฝะฐ ะทะฐะฑะพะปะตะฒะฐะฝะธั
rus_verbs:ัะตััะธัะพะฒะฐัั{}, // ัะตััะธัะพะฒะฐัั ะฝะฐ ะฟัะพัะฟัะธะณะพะดะฝะพััั
rus_verbs:ะฟัะพัะตััะธัะพะฒะฐัั{}, // ะฟัะพัะตััะธัะพะฒะฐัั ะฝะฐ ะฟัะพัะฟัะธะณะพะดะฝะพััั
rus_verbs:ัั
ะพะดะธัั{}, // ะพัะตั, ัั
ะพะดััะธะน ะฝะฐ ัะฐะฑะพัั
rus_verbs:ะฝะฐะปะธะฟะฝััั{}, // ัะฝะตะณ, ะฝะฐะปะธะฟัะธะน ะฝะฐ ะฟัะพะฒะพะดะฐ
rus_verbs:ะฝะฐะปะธะฟะฐัั{}, // ัะฝะตะณ, ะฝะฐะปะธะฟะฐััะธะน ะฝะฐ ะฟัะพะฒะพะดะฐ
rus_verbs:ัะปะตัะฐัั{}, // ะะฝะพะณะธะต ะฟัะธัั ัะปะตัะฐัั ะพัะตะฝัั ะฝะฐ ัะณ.
rus_verbs:ะฟะพะตั
ะฐัั{}, // ะพะฝะฐ ะฟะพะตั
ะฐะปะฐ ะฝะฐ ะฒัััะตัั ั ะทะฐะบะฐะทัะธะบะพะผ
rus_verbs:ะฟะตัะตะบะปััะฐัั{}, // ะฟะตัะตะบะปััะฐัั ะฝะฐ ัะตะทะตัะฒะฝัั ะปะธะฝะธั
rus_verbs:ะฟะตัะตะบะปััะฐัััั{}, // ะฟะตัะตะบะปััะฐัััั ะฝะฐ ัะตะทะตัะฒะฝัั ะปะธะฝะธั
rus_verbs:ะฟะพะดะฟะธัะฐัััั{}, // ะฟะพะดะฟะธัะฐัััั ะฝะฐ ะพะฑะฝะพะฒะปะตะฝะธะต
rus_verbs:ะฝะฐะฝะตััะธ{}, // ะฝะฐะฝะตััะธ ะฝะฐ ะบะพะถั
rus_verbs:ะฝะฐััะฒะฐัััั{}, // ะฝะฐััะฒะฐัััั ะฝะฐ ะฝะตะฟัะธััะฝะพััะธ
rus_verbs:ะฒัะฒะพะดะธัั{}, // ะฒัะฒะพะดะธัั ะฝะฐ ะพัะฑะธัั
rus_verbs:ะฒะตัะฝััััั{}, // ะฒะตัะฝััััั ะฝะฐ ัะพะดะธะฝั
rus_verbs:ะฒะพะทะฒัะฐัะฐัััั{}, // ะฒะพะทะฒัะฐัะฐัััั ะฝะฐ ัะพะดะธะฝั
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะฐะดะบะธะน{}, // ะะฝ ะฟะฐะดะพะบ ะฝะฐ ะดะตะฝัะณะธ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะพะฑะธะถะตะฝะฝัะน{}, // ะะฝ ะพะฑะธะถะตะฝ ะฝะฐ ะพััะฐ.
rus_verbs:ะบะพัะธัั{}, // ะะฝ ะบะพัะธั ะฝะฐ ะพะฑะฐ ะณะปะฐะทะฐ.
rus_verbs:ะทะฐะบัััั{}, // ะะฝ ะทะฐะฑัะป ะทะฐะบัััั ะดะฒะตัั ะฝะฐ ะทะฐะผะพะบ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะณะพัะพะฒัะน{}, // ะะฝ ะณะพัะพะฒ ะฝะฐ ะฒััะบะธะต ะถะตััะฒั.
rus_verbs:ะณะพะฒะพัะธัั{}, // ะะฝ ะณะพะฒะพัะธั ะฝะฐ ัะบะพะปัะทะบัั ัะตะผั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะณะปัั
ะพะน{}, // ะะฝ ะณะปัั
ะฝะฐ ะพะดะฝะพ ัั
ะพ.
rus_verbs:ะฒะทััั{}, // ะะฝ ะฒะทัะป ัะตะฑัะฝะบะฐ ัะตะฑะต ะฝะฐ ะบะพะปะตะฝะธ.
rus_verbs:ะพะบะฐะทัะฒะฐัั{}, // ะะตะบะฐัััะฒะพ ะฝะต ะพะบะฐะทัะฒะฐะปะพ ะฝะฐ ะฝะตะณะพ ะฝะธะบะฐะบะพะณะพ ะดะตะนััะฒะธั.
rus_verbs:ะฒะตััะธ{}, // ะะตััะฝะธัะฐ ะฒะตะดัั ะฝะฐ ััะตัะธะน ััะฐะถ.
rus_verbs:ัะฟะพะปะฝะพะผะพัะธะฒะฐัั{}, // ัะฟะพะปะฝะพะผะพัะธะฒะฐัั ะฝะฐ ััะพ-ะปะธะฑะพ
ะณะปะฐะณะพะป:ัะฟะตัะธัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะฏ ัะฟะตัั ะฝะฐ ะฟะพะตะทะด.
rus_verbs:ะฑัะฐัั{}, // ะฏ ะฑะตัั ะฒัั ะพัะฒะตัััะฒะตะฝะฝะพััั ะฝะฐ ัะตะฑั.
rus_verbs:ะฟัะพะธะทะฒะตััะธ{}, // ะญัะพ ะฟัะพะธะทะฒะตะปะพ ะฝะฐ ะผะตะฝั ะณะปัะฑะพะบะพะต ะฒะฟะตัะฐัะปะตะฝะธะต.
rus_verbs:ัะฟะพััะตะฑะธัั{}, // ะญัะธ ะดะตะฝัะณะธ ะผะพะถะฝะพ ัะฟะพััะตะฑะธัั ะฝะฐ ัะตะผะพะฝั ัะฐะฑัะธะบะธ.
rus_verbs:ะฝะฐะฒะพะดะธัั{}, // ะญัะฐ ะฟะตัะฝั ะฝะฐะฒะพะดะธั ะฝะฐ ะผะตะฝั ัะพะฝ ะธ ัะบัะบั.
rus_verbs:ัะฐะทะฑะธัะฐัััั{}, // ะญัะฐ ะผะฐัะธะฝะฐ ัะฐะทะฑะธัะฐะตััั ะฝะฐ ัะฐััะธ.
rus_verbs:ะพะบะฐะทะฐัั{}, // ะญัะฐ ะบะฝะธะณะฐ ะพะบะฐะทะฐะปะฐ ะฝะฐ ะผะตะฝั ะฑะพะปััะพะต ะฒะปะธัะฝะธะต.
rus_verbs:ัะฐะทะฑะธัั{}, // ะฃัะธัะตะปั ัะฐะทะฑะธะป ััะตะฝะธะบะพะฒ ะฝะฐ ะฝะตัะบะพะปัะบะพ ะณััะฟะฟ.
rus_verbs:ะพััะฐะทะธัััั{}, // ะฃัะธะปะตะฝะฝะฐั ัะฐะฑะพัะฐ ะพััะฐะทะธะปะฐัั ะฝะฐ ะตะณะพ ะทะดะพัะพะฒัะต.
rus_verbs:ะฟะตัะตะณััะทะธัั{}, // ะฃะณะพะปั ะฝะฐะดะพ ะฟะตัะตะณััะทะธัั ะฝะฐ ะดััะณะพะต ััะดะฝะพ.
rus_verbs:ะดะตะปะธัััั{}, // ะขัะธะดัะฐัั ะดะตะปะธััั ะฝะฐ ะฟััั ะฑะตะท ะพััะฐัะบะฐ.
rus_verbs:ัะดะฐะปััััั{}, // ะกัะด ัะดะฐะปัะตััั ะฝะฐ ัะพะฒะตัะฐะฝะธะต.
rus_verbs:ะฟะพะบะฐะทัะฒะฐัั{}, // ะกััะตะปะบะฐ ะบะพะผะฟะฐัะฐ ะฒัะตะณะดะฐ ะฟะพะบะฐะทัะฒะฐะตั ะฝะฐ ัะตะฒะตั.
rus_verbs:ัะพั
ัะฐะฝะธัั{}, // ะกะพั
ัะฐะฝะธัะต ััะพ ะฝะฐ ะฟะฐะผััั ะพะฑะพ ะผะฝะต.
rus_verbs:ัะตะทะถะฐัั{}, // ะกะตะนัะฐั ะฒัะต ัััะดะตะฝัั ัะตะทะถะฐัั ะฝะฐ ัะบัะบัััะธั.
rus_verbs:ะปะตัะตัั{}, // ะกะฐะผะพะปัั ะปะตัะธั ะฝะฐ ัะตะฒะตั.
rus_verbs:ะฑะธัั{}, // ะ ัะถัั ะฑััั ะฝะฐ ะฟััััะพั ะผะตััะพะฒ.
// rus_verbs:ะฟัะธะนัะธัั{}, // ะััะพะต ัะธัะปะพ ะฟัะธัะปะพัั ะฝะฐ ััะฑะฑะพัั.
rus_verbs:ะฒัะฝะตััะธ{}, // ะะฝะธ ะฒัะฝะตัะปะธ ะธะท ะปะพะดะบะธ ะฝะฐ ะฑะตัะตะณ ะฒัะต ะฒะตัะธ.
rus_verbs:ัะผะพััะตัั{}, // ะะฝะฐ ัะผะพััะธั ะฝะฐ ะฝะฐั ะธะท ะพะบะฝะฐ.
rus_verbs:ะพัะดะฐัั{}, // ะะฝะฐ ะพัะดะฐะปะฐ ะผะฝะต ะดะตะฝัะณะธ ะฝะฐ ัะพั
ัะฐะฝะตะฝะธะต.
rus_verbs:ะฝะฐะปัะฑะพะฒะฐัััั{}, // ะะต ะผะพะณั ะฝะฐะปัะฑะพะฒะฐัััั ะฝะฐ ะบะฐััะธะฝั.
rus_verbs:ะปัะฑะพะฒะฐัััั{}, // ะณะพััะธ ะปัะฑะพะฒะฐะปะธัั ะฝะฐ ะบะฐััะธะฝั
rus_verbs:ะฟะพะฟัะพะฑะพะฒะฐัั{}, // ะะฐะนัะต ะผะฝะต ะฟะพะฟัะพะฑะพะฒะฐัั ะฝะฐ ะพััะฟั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะดะตะนััะฒะธัะตะปัะฝัะน{}, // ะัะธะฒะธะฒะบะฐ ะพัะฟั ะดะตะนััะฒะธัะตะปัะฝะฐ ัะพะปัะบะพ ะฝะฐ ััะธ ะณะพะดะฐ.
rus_verbs:ัะฟัััะธัััั{}, // ะะฐ ะณะพัะพะด ัะฟัััะธะปัั ัะผะพะณ
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะตัะธัััะน{}, // ะะฝ ะฝะตัะธัั ะฝะฐ ััะบั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะตัะฟะพัะพะฑะฝัะน{}, // ะะฝ ะฝะตัะฟะพัะพะฑะตะฝ ะฝะฐ ัะฐะบัั ะฝะธะทะพััั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะทะปะพะน{}, // ะบะพั ะพัะตะฝั ะทะพะป ะฝะฐ ั
ะพะทัะธะฝะฐ
rus_verbs:ะฟะพะนัะธ{}, // ะะตะฒะพัะบะฐ ะฝะต ะฟะพัะปะฐ ะฝะฐ ััะพะบ ัะธะทัะปััััั
rus_verbs:ะฟัะธะฑัะฒะฐัั{}, // ะผะพะน ะฟะพะตะทะด ะฟัะธะฑัะฒะฐะตั ะฝะฐ ะฟะตัะฒัะน ะฟััั
rus_verbs:ะทะฐััะตะณะธะฒะฐัััั{}, // ะฟะฐะปััะพ ะทะฐััะตะณะธะฒะฐะตััั ะฝะฐ ะดะฒะฐะดัะฐัั ะพะดะฝั ะฟัะณะพะฒะธัั
rus_verbs:ะธะดัะธ{}, // ะะตะปะพ ะธะดัั ะฝะฐ ะปะฐะด.
rus_verbs:ะปะฐะทะธัั{}, // ะะฝ ะปะฐะทะธะป ะฝะฐ ัะตัะดะฐะบ.
rus_verbs:ะฟะพะดะดะฐะฒะฐัััั{}, // ะะฝ ะปะตะณะบะพ ะฟะพะดะดะฐัััั ะฝะฐ ัะณะพะฒะพัั.
// rus_verbs:ะดะตะนััะฒะพะฒะฐัั{}, // ะดะตะนััะฒัััะธะน ะฝะฐ ะฝะตัะฒั
rus_verbs:ะฒัั
ะพะดะธัั{}, // ะะฐะปะบะพะฝ ะฒัั
ะพะดะธั ะฝะฐ ะฟะปะพัะฐะดั.
rus_verbs:ัะฐะฑะพัะฐัั{}, // ะัะตะผั ัะฐะฑะพัะฐะตั ะฝะฐ ะฝะฐั.
ะณะปะฐะณะพะป:ะฝะฐะฟะธัะฐัั{aux stress="ะฝะฐะฟะธั^ะฐัั"}, // ะะฝ ะฝะฐะฟะธัะฐะป ะผัะทัะบั ะฝะฐ ัะปะพะฒะฐ ะััะบะธะฝะฐ.
rus_verbs:ะฑัะพัะธัั{}, // ะะฝะธ ะฑัะพัะธะปะธ ะฒัะต ัะธะปั ะฝะฐ ัััะพะธัะตะปัััะฒะพ.
// ะณะปะฐะณะพะป:ัะฐะทัะตะทะฐัั{aux stress="ัะฐะทั^ะตะทะฐัั"}, ะณะปะฐะณะพะป:ัะฐะทัะตะทะฐัั{aux stress="ัะฐะทัะตะท^ะฐัั"}, // ะะฝะฐ ัะฐะทัะตะทะฐะปะฐ ะฟะธัะพะณ ะฝะฐ ัะตััั ะบััะบะพะฒ.
rus_verbs:ะฑัะพัะธัััั{}, // ะะฝะฐ ัะฐะดะพััะฝะพ ะฑัะพัะธะปะฐัั ะผะฝะต ะฝะฐ ัะตั.
rus_verbs:ะพะฟัะฐะฒะดะฐัั{}, // ะะฝะฐ ะพะฟัะฐะฒะดะฐะปะฐ ะฝะตัะฒะบั ะฝะฐ ะทะฐะฝััะธั ะฑะพะปะตะทะฝัั.
rus_verbs:ะพัะฒะตัะธัั{}, // ะะฝะฐ ะฝะต ะพัะฒะตัะธะปะฐ ะฝะฐ ะผะพะน ะฟะพะบะปะพะฝ.
rus_verbs:ะฝะฐัะธะฒะฐัั{}, // ะะฝะฐ ะฝะฐัะธะฒะฐะปะฐ ะทะฐะฟะปะฐัั ะฝะฐ ะปะพะบะพัั.
rus_verbs:ะผะพะปะธัััั{}, // ะะฝะฐ ะผะพะปะธััั ะฝะฐ ัะฒะพั ะผะฐัั.
rus_verbs:ะทะฐะฟะตัะตัั{}, // ะะฝะฐ ะทะฐะฟะตัะปะฐ ะดะฒะตัั ะฝะฐ ะทะฐะผะพะบ.
rus_verbs:ะทะฐัะฒะธัั{}, // ะะฝะฐ ะทะฐัะฒะธะปะฐ ัะฒะพะธ ะฟัะฐะฒะฐ ะฝะฐ ะฝะฐัะปะตะดััะฒะพ.
rus_verbs:ัะนัะธ{}, // ะัะต ะดะตะฝัะณะธ ััะปะธ ะฝะฐ ะฟััะตัะตััะฒะธะต.
rus_verbs:ะฒัััะฟะธัั{}, // ะะพะดะพะปะฐะท ะฒัััะฟะธะป ะฝะฐ ะฑะตัะตะณ.
rus_verbs:ัะพะนัะธ{}, // ะะพัั ัะพัะปะฐ ะฝะฐ ะทะตะผะปั.
rus_verbs:ะฟัะธะตั
ะฐัั{}, // ะั ะฟัะธะตั
ะฐะปะธ ะฝะฐ ะฒะพะบะทะฐะป ัะปะธัะบะพะผ ัะฐะฝะพ.
rus_verbs:ััะดะฐัั{}, // ะะต ััะดะฐะน ัะฐะบ ะฑะตะทัะผะฝะพ ะฝะฐะด ะฝะธะผ.
rus_verbs:ะฟะพะดะฟะธัะฐัั{}, // ะะต ะทะฐะฑัะดััะต ะฟะพะดะฟะธัะฐัั ะผะตะฝั ะฝะฐ ะณะฐะทะตัั.
rus_verbs:ะดะตัะถะฐัั{}, // ะะฐั ะฟะฐัะพั
ะพะด ะดะตัะถะฐะป ะบััั ะฟััะผะพ ะฝะฐ ัะตะฒะตั.
rus_verbs:ัะฒะตะทัะธ{}, // ะะฐ ะฒัััะฐะฒะบั ัะฒะตะทะปะธ ัะบัะฟะพะฝะฐัั ัะพ ะฒัะตะณะพ ะผะธัะฐ.
rus_verbs:ะตั
ะฐัั{}, // ะั ัะตะนัะฐั ะตะดะตะผ ะฝะฐ ะทะฐะฒะพะด.
rus_verbs:ะฒัะฑัะพัะธัั{}, // ะะพะปะฝะฐะผะธ ะปะพะดะบั ะฒัะฑัะพัะธะปะพ ะฝะฐ ะฑะตัะตะณ.
ะะ_ะะะค(ัะตััั), // ัะตััั ะฝะฐ ัะฝะตะณ
ะะ_ะะะค(ะทะฐะฟะธัะฐัััั),
ะะ_ะะะค(ะฟะพะปะพะถะธัั) // ะฟะพะปะพะถะธ ะบะฝะธะณั ะฝะฐ ััะพะป
}
#endregion VerbList
// ะงัะพะฑั ัะฐะทัะตัะธัั ัะฒัะทัะฒะฐะฝะธะต ะฒ ะฟะฐััะตัะฝะฐั
ัะธะฟะฐ: ะทะฐะปะธัั ะฝะฐ youtube
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะ_ะะธะฝ ะฟัะตะดะปะพะณ:ะฝะฐ{} @regex("[a-z]+[0-9]*") }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะณะปะฐะณะพะป:ะบัะฟะธัั{} ะฟัะตะดะปะพะณ:ะฝะฐ{} 'ะดะตะฝัะณะธ'{ะฟะฐะดะตะถ:ะฒะธะฝ} }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะ_ะะธะฝ ะฟัะตะดะปะพะณ:ะฝะฐ{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return true
}
// ัะผะตัะฐัััั ะฝะฐ ะฝะตัะบะพะปัะบะพ ะผะธะปะปะธะผะตััะพะฒ
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะ_ะะธะฝ ะฟัะตะดะปะพะณ:ะฝะฐ{} ะฝะฐัะตัะธะต:*{} }
then return true
}
// ะฟะฐััะธั ะฒะทัะปะฐ ะฝะฐ ัะตะฑั ะฝะตัะตะฐะปะธััะธัะฝัะต ะพะฑัะทะฐัะตะปัััะฒะฐ
fact ะณะป_ะฟัะตะดะป
{
if context { ะณะปะฐะณะพะป:ะฒะทััั{} ะฟัะตะดะปะพะณ:ะฝะฐ{} 'ัะตะฑั'{ะฟะฐะดะตะถ:ะฒะธะฝ} }
then return true
}
#endregion ะะะะะขะะะฌะะซะ
// ะัะต ะพััะฐะปัะฝัะต ะฒะฐัะธะฐะฝัั ั ะฟัะตะดะปะพะณะพะผ 'ะะ' ะฟะพ ัะผะพะปัะฐะฝะธั ะทะฐะฟัะตัะฐะตะผ.
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฝะฐ{} *:*{ ะฟะฐะดะตะถ:ะฟัะตะดะป } }
then return false,-3
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฝะฐ{} *:*{ ะฟะฐะดะตะถ:ะผะตัั } }
then return false,-3
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฝะฐ{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return false,-4
}
// ะญัะพั ะฒะฐัะธะฐะฝั ะฝัะถะตะฝ ะดะปั ะพะฑัะฐะฑะพัะบะธ ะบะพะฝััััะบัะธะน ั ัะธัะปะธัะตะปัะฝัะผะธ:
// ะัะตะทะธะดะตะฝััะบะธะต ะฒัะฑะพัั ัะฐะทะดะตะปะธะปะธ ะะตะฝะตัััะปั ะฝะฐ ะดะฒะฐ ะฝะตะฟัะธะผะธัะธะผัั
ะปะฐะณะตัั
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฝะฐ{} *:*{ ะฟะฐะดะตะถ:ัะพะด } }
then return false,-4
}
// ะัะพะดะฐะฒะฐัั ะฝะฐ eBay
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฝะฐ{} * }
then return false,-6
}
#endregion ะัะตะดะปะพะณ_ะะ
#region ะัะตะดะปะพะณ_ะก
// ------------- ะะ ะะะะะ 'ะก' -----------------
// ะฃ ััะพะณะพ ะฟัะตะดะปะพะณะฐ ะฟัะตะดะฟะพััะธัะตะปัะฝะฐั ัะตะผะฐะฝัะธะบะฐ ะฟัะธะฒัะทัะฒะฐะตั ะตะณะพ ะพะฑััะฝะพ ะบ ัััะตััะฒะธัะตะปัะฝะพะผั.
// ะะพััะพะผั ะทะฐะฟัะตัะฐะตะผ ะฟะพ ัะผะพะปัะฐะฝะธั ะตะณะพ ะฟัะธะฒัะทะบั ะบ ะณะปะฐะณะพะปะฐะผ, ะฐ ัะฐะทัะตัะตะฝะฝัะต ะณะปะฐะณะพะปั ะฟะตัะตัะธัะปะธะผ.
#region ะขะะะ ะะขะะะฌะะซะ
wordentry_set ะะป_ะก_ะขะฒะพั={
rus_verbs:ะฟะพะผะพะณะฐัั{}, // ะฑัะดะตั ะณะพัะพะฒ ะฟะพะผะพะณะฐัั ะฒัะฐัะฐะผ ะฒ ะพะฝะบะพะปะพะณะธัะตัะบะพะผ ัะตะฝััะต ั ะฟะพััะฐะฝะพะฒะบะพะน ะฒะตัะฝัั
ะดะธะฐะณะฝะพะทะพะฒ
rus_verbs:ะฟะตัะตะฟะธั
ะฝััััั{}, // ะฝะตัะถะตะปะธ ัั ะฝะต ั
ะพัะตัั ัะพ ะผะฝะพะน ะฟะตัะตะฟะธั
ะฝััััั
rus_verbs:ะทะฐะฑัะฐัััั{},
rus_verbs:ะะ ะะขะฌะกะฏ{}, // ะะพะธ ะถะต ัะพะฑััะฒะตะฝะฝัะต ัะฐัะฝะธะบะธ ะทะฐะฑัะพัะฐะปะธ ะฑั ะผะตะฝั ะณะฝะธะปะพะน ะบะฐะฟัััะพะน, ะธ ะผะฝะต ะฟัะธัะปะพัั ะฑั ะดัะฐัััั ั ะบะฐะถะดัะผ ัััะฐัะตะผ ะฒ ัััะฐะฝะต, ััะพะฑั ะดะพะบะฐะทะฐัั ัะฒะพั ัะผะตะปะพััั. (ะะ ะะขะฌะกะฏ/ะะะขะฌะกะฏ/ะะะะ ะะขะฌะกะฏ)
rus_verbs:ะะะขะฌะกะฏ{}, //
rus_verbs:ะะะะ ะะขะฌะกะฏ{}, //
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะกะฅะะะะ{}, // ะะต ะฑัะป ะปะธ ะพะฝ ัั
ะพะถะธะผ ั ะพะดะฝะธะผ ะธะท ะถะธะฒัั
ัะทัะบะพะฒ ะะตะผะปะธ (ะกะฅะะะะ)
rus_verbs:ะะกะขะฃะะะขะฌ{}, // ะะฝ ะฝะฐะผะตัะตะฒะฐะปัั ะฒัััะฟะธัั ั ะะพะปััะพะผ ะฒ ะฑะปะธะถะฝะธะน ะฑะพะน. (ะะกะขะฃะะะขะฌ)
rus_verbs:ะะะ ะ ะะะะ ะะะะขะฌ{}, // ะญัะพ ะบะพััะตะปะธััะตั ั ััะฐะดะธัะธะพะฝะฝะพ ัะธะปัะฝัะผะธ ะฝะฐะฟัะฐะฒะปะตะฝะธัะผะธ ะผะพัะบะพะฒัะบะพะน ะผะฐัะตะผะฐัะธัะตัะบะพะน ัะบะพะปั. (ะะะ ะ ะะะะ ะะะะขะฌ)
rus_verbs:ะฃะะะะะขะฌะกะฏ{}, // ะะฝ ะฟัะพะธะณะฝะพัะธััะตั ะธััะตัะธัะตัะบะธะต ะฟัะพัะตััั ะถะตะฝั ะธ ัะฒะธะดะธััั ัะฝะฐัะฐะปะฐ ั ะดะพะบัะพัะพะผ, ะฐ ะทะฐัะตะผ ั ะฟัะธั
ะพัะตัะฐะฟะตะฒัะพะผ (ะฃะะะะะขะฌะกะฏ)
rus_verbs:ะะงะะฃะขะฌะกะฏ{}, // ะะพะณะดะฐ ะพะฝ ะพัะฝัะปัั ั ะฑะพะปัั ะฒ ะปะตะฒะพะน ััะพัะพะฝะต ัะตัะตะฟะฐ, ั ะฝะตะณะพ ะฒะพะทะฝะธะบะปะพ ะฟัะณะฐััะตะต ะพัััะตะฝะธะต. (ะะงะะฃะขะฌะกะฏ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัั
ะพะดะฝัะน{}, // ะะพะทะณ ััะธั
ัััะตััะฒ ัั
ะพะดะตะฝ ะฟะพ ัะฐะทะผะตัะฐะผ ั ะผะพะทะณะพะผ ะดะธะฝะพะทะฐะฒัะฐ
rus_verbs:ะฝะฐะบัััััั{}, // ะัะปะพ ั
ะพะปะพะดะฝะพ, ะธ ะพะฝ ะฝะฐะบััะปัั ั ะณะพะปะพะฒะพะน ะพะดะตัะปะพะผ.
rus_verbs:ะ ะะกะะ ะะะะะะขะฌ{}, // ะัะดะถะตั ัะฐัะฟัะตะดะตะปัั ั ััะฐััะธะตะผ ะณะพัะพะถะฐะฝ (ะ ะะกะะ ะะะะะะขะฌ)
rus_verbs:ะะะะ ะะกะะขะฌะกะฏ{}, // ะััะฝัะน ะฒะพะดะธัะตะปั ะฝะฐะฑัะพัะธะปัั ั ะฝะพะถะพะผ ะฝะฐ ัะพัััะดะฝะธะบะพะฒ ะะะะะ (ะะะะ ะะกะะขะฌะกะฏ)
rus_verbs:ะะ ะะกะะขะฌะกะฏ{}, // ะพะฝะฐ ัะพ ัะผะตั
ะพะผ ะฑัะพัะธะปะฐัั ะฟัะพัั (ะะ ะะกะะขะฌะกะฏ)
rus_verbs:ะะะะขะะะขะะ ะะะะขะฌ{}, // ะญะปะตะบััะพะฝะฝัะผ ะผะฐะณะฐะทะธะฝะฐะผ ััะพะธั ะบะพะฝัะฐะบัะธัะพะฒะฐัั ั ะบะปะธะตะฝัะฐะผะธ (ะะะะขะะะขะะ ะะะะขะฌ)
rus_verbs:ะะะะะขะฌะกะฏ{}, // ะขะพะณะดะฐ ะผั ัะตะดะบะพ ะฒะธะดะตะปะธัั ะดััะณ ั ะดััะณะพะผ
rus_verbs:ัะตััั{}, // ัะตะป ะฒ ะฝะตะณะพ ั ะดะพัะพะถะฝะพะน ััะผะบะพะน , ะฝะฐะฟะพะปะฝะตะฝะฝะพะน ะฝะฐัะบะพัะธะบะฐะผะธ
rus_verbs:ะบัะฟะธัั{}, // ะั ะบัะฟะธะปะธ ั ะฝะธะผ ะพะดะฝั ะธ ัั ะถะต ะบะฝะธะณั
rus_verbs:ะะ ะะะะะฏะขะฌ{}, // ะะตัั ะฟะพ ััะธะผัะปะธัะพะฒะฐะฝะธั ัะฟัะพัะฐ ะฒ ะ ะค ัะปะตะดัะตั ะฟัะธะผะตะฝััั ั ะพััะพัะพะถะฝะพัััั (ะะ ะะะะะฏะขะฌ)
rus_verbs:ะฃะะขะ{}, // ัั ะผะพะณ ะฑั ัะนัะธ ัะพ ะผะฝะพะน (ะฃะะขะ)
rus_verbs:ะะะะขะฌ{}, // ะก ะฝะฐัะฐััะฐััะธะผ ะปัะฑะพะฟััััะฒะพะผ ะถะดะตะผ ัะตะทัะปััะฐัะพะฒ ะฐัะดะธัะฐ ะทะพะปะพััั
ั
ัะฐะฝะธะปะธั ะตะฒัะพะฟะตะนัะบะธั
ะธ ะฐะผะตัะธะบะฐะฝัะบะธั
ัะตะฝััะพะฑะฐะฝะบะพะฒ (ะะะะขะฌ)
rus_verbs:ะะะกะะะขะะะะะะ ะะะะขะฌ{}, // ะััะฐ ะขะฒะตัะธ, ััะฐััะฒะพะฒะฐะฒัะตะณะพ ะฒ ัะฟะฐััะฐะบะธะฐะดะต, ะณะพัะฟะธัะฐะปะธะทะธัะพะฒะฐะปะธ ั ะธะฝัะฐัะบัะพะผ (ะะะกะะะขะะะะะะ ะะะะขะฌ)
rus_verbs:ะะะฅะะะะะฃะขะฌะกะฏ{}, // ะพะฝะฐ ะทะฐั
ะปะพะฟะฝัะปะฐัั ัะพ ะทะฒะพะฝะพะผ (ะะะฅะะะะะฃะขะฌะกะฏ)
rus_verbs:ะะขะะะ ะะฃะขะฌะกะฏ{}, // ะพะฝะฐ ัะพ ะฒะทะดะพั
ะพะผ ะพัะฒะตัะฝัะปะฐัั (ะะขะะะ ะะฃะขะฌะกะฏ)
rus_verbs:ะพัะฟัะฐะฒะธัั{}, // ะฒั ะผะพะถะตัะต ะพัะฟัะฐะฒะธัั ัะพ ะผะฝะพะน ัะตะปะพะฒะตะบะฐ
rus_verbs:ะฒััััะฟะฐัั{}, // ะัะฐะดะพะฝะฐัะฐะปัะฝะธะบ , ะฒััััะฟะฐั ั ะพะฑะทะพัะพะผ ะพัะฝะพะฒะฝัั
ะณะพัะพะดัะบะธั
ัะพะฑััะธะน , ะฟะพะฒะตะดะฐะป ะพะฑ ััะพะผ ะดะตะฟััะฐัะฐะผ
rus_verbs:ะะซะะะะะขะฌ{}, // ะทะฐะบะปััะตะฝะฝัะต ัะฐะผะธ ัััั ะบัะบะปั ะธ ะธะฝะพะณะดะฐ ะฒัะตะทะถะฐัั ั ะฟัะตะดััะฐะฒะปะตะฝะธัะผะธ ะฒ ะดะตััะบะธะน ะดะพะผ ะฝะตะฟะพะดะฐะปะตะบั (ะะซะะะะะขะฌ ะก ัะฒะพั)
rus_verbs:ะะะะะะงะะขะฌ{}, // ัะพ ะฒัะตะผ ััะธะผ ะฟะพะบะพะฝัะตะฝะพ (ะะะะะะงะะขะฌ ะก)
rus_verbs:ะะะะะะะขะฌ{}, // ะะผะธััะธะน ะฟะพะฑะตะถะฐะป ัะพ ะฒัะตะผะธ (ะะะะะะะขะฌ ะก)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะตัะพะฒะผะตััะธะผัะน{}, // ั
ะฐัะฐะบัะตั ัะฐะฝะตะฝะธะน ะฑัะป ะฝะตัะพะฒะผะตััะธะผ ั ะถะธะทะฝัั (ะะะกะะะะะกะขะะะซะ ะก)
rus_verbs:ะะะกะะขะะขะฌ{}, // ะะณะพ ะบะฐะฑะธะฝะตั ะผะตััะฝัะต ัะตะปะตะถััะฝะฐะปะธััั ะฟะพัะตัะธะปะธ ัะพ ัะบัััะพะน ะบะฐะผะตัะพะน (ะะะกะะขะะขะฌ ะก)
rus_verbs:ะกะะะะะขะฌะกะฏ{}, // ัะฐะผะธ ะฑะฐะฝะบะธ ะฟัะธะฝะธะผะฐัั ะผะตัั ะฟะพ ััะตะณัะปะธัะพะฒะฐะฝะธั ัะปะพะถะธะฒัะตะนัั ั ะฒะบะปะฐะดัะธะบะฐะผะธ ัะธััะฐัะธะธ (ะกะะะะะขะฌะกะฏ ะก)
rus_verbs:ะะะกะขะะขะฌ{}, // ะะพะปะพะดะพะน ัะตะปะพะฒะตะบ ัะฑะธะป ะฟะตะฝัะธะพะฝะตัะฐ , ะทะฐััะฐะฒ ะตะณะพ ะฒ ะฟะพััะตะปะธ ั ะถะตะฝะพะน (ะะะกะขะะขะฌ ะก)
rus_verbs:ะะะะะะะะะะะะขะฌะกะฏ{}, // ะฟัะธ ะทะฐะฟะพะปะฝะตะฝะธะธ ะทะฐัะฒะปะตะฝะธั ะฒะปะฐะดะตะปััั ััะดะพะฒ ะพะทะฝะฐะบะฐะผะปะธะฒะฐัััั ั ัะตะถะธะผะพะผ (ะะะะะะะะะะะะขะฌะกะฏ ะก)
rus_verbs:ะกะะะะ ะะะะะซะะะขะฌ{}, // ะ ะฒัะต ัะฒะพะธ ะทะฐะดะฐัะธ ะผั ัะพะพะฑัะฐะทะพะฒัะฒะฐะตะผ ั ััะธะผ ะฟะพะฝะธะผะฐะฝะธะตะผ (ะกะะะะ ะะะะะซะะะขะฌ ะก)
rus_verbs:ะกะะซะะะขะฌะกะฏ{},
rus_verbs:ััะฐัะบะธะฒะฐัััั{},
rus_verbs:ัะฟะธะปะธะฒะฐัััั{},
rus_verbs:ะะะะะฃะ ะะ ะะะะขะฌ{}, // ะะตะดะฝัะต ะธ ะผะตะฝะตะต ัะฐะทะฒะธััะต ัััะฐะฝั ะฝะต ะผะพะณัั ะบะพะฝะบััะธัะพะฒะฐัั ั ััะธะผะธ ััะฑัะธะดะธัะผะธ (ะะะะะฃะ ะะ ะะะะขะฌ ะก)
rus_verbs:ะะซะ ะะะขะฌะกะฏ{}, // ัะพั ั ัััะดะพะผ ะฒััะฒะฐะปัั (ะะซะ ะะะขะฌะกะฏ ะก ัะฒะพั)
rus_verbs:ะกะะะ ะะขะฌะกะฏ{}, // ะฝัะถะฝะพ ัะพะฑัะฐัััั ั ัะธะปะฐะผะธ (ะกะะะ ะะขะฌะกะฏ ะก)
rus_verbs:ะฃะะะะะขะฌะกะฏ{}, // ัะดะฐะฒะฐะปะพัั ััะพ ั ัััะดะพะผ (ะฃะะะะะขะฌะกะฏ ะก)
rus_verbs:ะ ะะกะะะฅะะฃะขะฌะกะฏ{}, // ะดะฒะตัั ั ััะตัะบะพะผ ัะฐัะฟะฐั
ะฝัะปะฐัั (ะ ะะกะะะฅะะฃะขะฌะกะฏ ะก)
rus_verbs:ะะะะะฎะะะขะฌ{}, // ะะปะตะณ ะฝะฐะฑะปัะดะฐะป ั ะปัะฑะพะฟััััะฒะพะผ (ะะะะะฎะะะขะฌ ะก)
rus_verbs:ะะะขะฏะะฃะขะฌ{}, // ะทะฐัะตะผ ั ัะธะปะพะน ะฟะพััะฝัะป (ะะะขะฏะะฃะขะฌ ะก)
rus_verbs:ะะะะะฃะขะฌ{}, // ะะธัะตั ั ัััะดะพะผ ะบะธะฒะฝัะป (ะะะะะฃะขะฌ ะก)
rus_verbs:ะกะะะะขะะฃะขะฌ{}, // ะะพัะธั ั ัััะดะพะผ ัะณะปะพัะฝัะป (ะกะะะะขะะฃะขะฌ ะก)
rus_verbs:ะะะะ ะะขะฌ{}, // ะทะฐะฑัะฐัั ะตะณะพ ั ัะพะฑะพะน (ะะะะ ะะขะฌ ะก)
rus_verbs:ะะขะะ ะซะขะฌะกะฏ{}, // ะดะฒะตัั ั ัะธะฟะตะฝะธะตะผ ะพัะบััะปะฐัั (ะะขะะ ะซะขะฌะกะฏ ะก)
rus_verbs:ะะขะะ ะะะขะฌ{}, // ั ััะธะปะธะตะผ ะพัะพัะฒะฐะป ะฒะทะณะปัะด (ะะขะะ ะะะขะฌ ะก ัะฒะพั)
rus_verbs:ะะะะฏะะะขะฌะกะฏ{}, // ะ ะพะผะฐ ั ะปัะฑะพะฟััััะฒะพะผ ะพะณะปัะดะตะปัั (ะะะะฏะะะขะฌะกะฏ ะก)
rus_verbs:ะคะซะ ะะะฃะขะฌ{}, // ัััะพะบ ัััะบะฝัะป ั ะพัะฒัะฐัะตะฝะธะตะผ (ะคะซะ ะะะฃะขะฌ ะก)
rus_verbs:ัะพะณะปะฐัะธัััั{}, // ั ััะธะผ ัะพะณะปะฐัะธะปะธัั ะฒัะต (ัะพะณะปะฐัะธัััั ั)
rus_verbs:ะะะกะซะะะขะฌะกะฏ{}, // ั ะณัะพั
ะพัะพะผ ะฟะพััะฟะฐะปะธัั ะบะฐะผะฝะธ (ะะะกะซะะะขะฌะกะฏ ะก ัะฒะพั)
rus_verbs:ะะะะะฅะะฃะขะฌ{}, // ะะปะธัะฐ ะฒะทะดะพั
ะฝัะปะฐ ั ะพะฑะปะตะณัะตะฝะธะตะผ (ะะะะะฅะะฃะขะฌ ะก)
rus_verbs:ะะะะ ะะฃะขะฌะกะฏ{}, // ัะฐ ั ัะดะธะฒะปะตะฝะธะตะผ ะพะฑะตัะฝัะปะฐัั (ะะะะ ะะฃะขะฌะกะฏ ะก)
rus_verbs:ะฅะะซะะะฃะขะฌ{}, // ะะปะตะบัะตะน ั
ะผัะบะฝัะป ั ัะพะผะฝะตะฝะธะตะผ (ะฅะะซะะะฃะขะฌ ะก ัะฒะพั)
rus_verbs:ะะซะะฅะะขะฌ{}, // ะพะฝะธ ะฒัะตั
ะฐะปะธ ั ัะฐััะฒะตัะพะผ (ะะซะะฅะะขะฌ ะก ัะฒะพั)
rus_verbs:ะะซะะะฅะะฃะขะฌ{}, // ะะปะฐะดะธะผะธั ะฒัะดะพั
ะฝัะป ั ะพะฑะปะตะณัะตะฝะธะตะผ (ะะซะะะฅะะฃะขะฌ ะก)
rus_verbs:ะฃะฅะะซะะฌะะฃะขะฌะกะฏ{}, // ะะตัะฐ ัั
ะผัะปัะฝัะปัั ั ัะพะผะฝะตะฝะธะตะผ (ะฃะฅะะซะะฌะะฃะขะฌะกะฏ ะก)
rus_verbs:ะะะกะขะะกะฌ{}, // ัะพั ะฝะตััั ั ะบัะธะบะพะผ (ะะะกะขะะกะฌ ะก ัะฒะพั)
rus_verbs:ะะะะะขะฌ{}, // ะฟะฐะดะฐัั ั ะณะปัั
ะธะผ ัััะบะพะผ (ะะะะะขะฌ ะก ัะฒะพั)
rus_verbs:ะขะะะ ะะขะฌะกะฏ{}, // ัััะฐะฝะฝะพะต ัะฒะพัะธะปะพัั ั ะณะปะฐะทะฐะผะธ (ะขะะะ ะะขะฌะกะฏ ะก ัะฒะพั)
rus_verbs:ะฃะฅะะะะขะฌ{}, // ั ะฝะธะผะธ ัั
ะพะดะธะปะธ ัะปััั (ะฃะฅะะะะขะฌ ะก ัะฒะพั)
rus_verbs:ะกะะะะะขะฌ{}, // ัะบะฐะบะฐะปะธ ััั ั ัะพะฟะพัะฐะผะธ (ะกะะะะะขะฌ ะก ัะฒะพั)
rus_verbs:ะะกะขะฌ{}, // ะทะดะตัั ะตะดัั ั ะทะตะปะตะฝัั (ะะกะขะฌ ะก ัะฒะพั)
rus_verbs:ะะะฏะะะขะฌะกะฏ{}, // ั ัะฐััะฒะตัะพะผ ะฟะพัะฒะธะปะธัั ะฟัะธัั (ะะะฏะะะขะฌะกะฏ ะก ัะฒะพั)
rus_verbs:ะะกะะะงะะขะฌ{}, // ะะปะตะณ ะฒัะบะพัะธะป ั ะณะพัะพะฒะฝะพัััั (ะะกะะะงะะขะฌ ะก ัะฒะพั)
rus_verbs:ะะซะขะฌ{}, // ั
ะพัั ะฑััั ั ัะพะฑะพะน (ะะซะขะฌ ะก ัะฒะพั)
rus_verbs:ะะะะะงะะขะฌ{}, // ั ัะพะผะฝะตะฝะธะตะผ ะฟะพะบะฐัะฐะป ะณะพะปะพะฒะพะน. (ะะะะะงะะขะฌ ะก ะกะะะะะะะะ)
rus_verbs:ะะซะ ะฃะะะขะฌะกะฏ{}, // ะบะฐะฟะธัะฐะฝ ั ััะฒััะฒะพะผ ะฒัััะณะฐะปัั (ะะซะ ะฃะะะขะฌะกะฏ ะก ะงะฃะะกะขะะะ)
rus_verbs:ะะขะะ ะซะขะฌ{}, // ั ัััะดะพะผ ะพัะบััะป ะณะปะฐะทะฐ (ะะขะะ ะซะขะฌ ะก ะขะ ะฃะะะ, ัะฐะบะธั
ะผะฝะพะณะพ)
rus_verbs:ะะะะฃะงะะขะฌะกะฏ{}, // ะทะฐะฑะฐะฒะฝะพ ะฟะพะปััะธะปะพัั ั ะฝะธะผ (ะะะะฃะงะะขะฌะกะฏ ะก)
rus_verbs:ะะซะะะะะขะฌ{}, // ััะฐััะน ะฒัะฑะตะถะฐะป ั ะบะพะฟัะตะผ (ะะซะะะะะขะฌ ะก)
rus_verbs:ะะะขะะะะขะฌะกะฏ{}, // ะะพะปััะธะฝััะฒะพ ะบะพะผะฟะพัะพะฒ ะณะพัะพะฒะธััั ั ะธัะฟะพะปัะทะพะฒะฐะฝะธะตะผ ัะฐั
ะฐัะฐ (ะะะขะะะะขะฌะกะฏ ะก)
rus_verbs:ะะะะะกะะฃะขะะ ะะะะขะฌ{}, // ั ะฑั ะฟะพะดะธัะบััะธัะพะฒะฐะป ั ะะฝะดััั
ะพะน (ะะะะะกะะฃะขะะ ะะะะขะฌ ะก)
rus_verbs:ะขะฃะกะะขะฌ{}, // ะบัะพ ัััะธะป ัะพ ะกะฒะตัะบะพะน (ะขะฃะกะะขะฌ ะก)
rus_verbs:ะะะะะขะฌ{}, // ะบัะดะฐ ะพะฝะฐ ะฑะตะถะธั ัะพ ะฒัะตะผะธ? (ะะะะะขะฌ ะก ัะฒะพั)
rus_verbs:ะะะ ะะขะฌ{}, // ัั ะณะพัะตะป ัะพ ัะฒะพะธะผ ะบะพัะฐะฑะปะตะผ? (ะะะ ะะขะฌ ะก)
rus_verbs:ะะซะะะขะฌ{}, // ั
ะพัะธัะต ะฒัะฟะธัั ัะพ ะผะฝะพะน ัะฐั? (ะะซะะะขะฌ ะก)
rus_verbs:ะะะะฏะขะฌะกะฏ{}, // ะฏ ะผะตะฝัััั ั ัะพะฒะฐัะธัะตะผ ะบะฝะธะณะฐะผะธ. (ะะะะฏะขะฌะกะฏ ะก)
rus_verbs:ะะะะฏะขะฌะกะฏ{}, // ะะฝ ัะถะต ะฝะตะดะตะปั ะฒะฐะปัะตััั ั ะณัะธะฟะฟะพะผ. (ะะะะฏะขะฌะกะฏ ะก)
rus_verbs:ะะะขะฌ{}, // ะฒั ะดะฐะถะต ะฑัะดะตัะต ะฟะธัั ัะพ ะผะฝะพะน ะฟะธะฒะพ. (ะะะขะฌ ะก)
ะธะฝัะธะฝะธัะธะฒ:ะบัะธััะฐะปะปะธะทะพะฒะฐัััั{ ะฒะธะด:ัะพะฒะตัั }, // ะะพัะปะต ััะพะณะพ ะฟะตัะตัััะตะฝะฝัะน ัะฐััะฒะพั ะบัะธััะฐะปะปะธะทัะตััั ั ะพะฑัะฐะทะพะฒะฐะฝะธะตะผ ะบัะธััะฐะปะปะพะฒ ัะฐั
ะฐัะฐ.
ะธะฝัะธะฝะธัะธะฒ:ะบัะธััะฐะปะปะธะทะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะณะปะฐะณะพะป:ะบัะธััะฐะปะปะธะทะพะฒะฐัััั{ ะฒะธะด:ัะพะฒะตัั },
ะณะปะฐะณะพะป:ะบัะธััะฐะปะปะธะทะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ะะะะะฉะะขะฌะกะฏ{}, // ะฟะพะพะฑัะฐะนัั ั ะะพัะธัะพะผ (ะะะะะฉะะขะฌะกะฏ ะก)
rus_verbs:ะะะะะะฏะขะฌะกะฏ{}, // ะะธัะฐ ะพะฑะผะตะฝัะปัั ั ะะตัะตะน ะผะฐัะบะฐะผะธ (ะะะะะะฏะขะฌะกะฏ ะก)
rus_verbs:ะะ ะะฅะะะะขะฌ{}, // ะผั ั ัะพะฑะพะน ัะตะณะพะดะฝั ะฒะตัั ะดะตะฝั ะฟัะพั
ะพะดะธะปะธ ั ะฒะตัะฐะผะธ. (ะะ ะะฅะะะะขะฌ ะก)
rus_verbs:ะะกะขะะขะฌ{}, // ะะฝ ะทะฐะฝะธะผะฐะปัั ะฒัั ะฝะพัั ะธ ะฒััะฐะป ั ะณะพะปะพะฒะฝะพะน ะฑะพะปัั. (ะะกะขะะขะฌ ะก)
rus_verbs:ะะะะ ะะะะะะขะฌ{}, // ะะะค ัะตะบะพะผะตะฝะดัะตั ะัะปะฐะฝะดะธะธ ะฟะพะฒัะตะผะตะฝะธัั ั ะผะตัะฐะผะธ ัะบะพะฝะพะผะธะธ (ะะะะ ะะะะะะขะฌ ะก)
rus_verbs:ะะะฏะะะขะฌ{}, // ะั ะณะปะฐะทะฐ ะณะปัะดะตะปะธ ั ะผัะณะบะพะน ะณัััััั. (ะะะฏะะะขะฌ ะก + ัะฒะพั)
rus_verbs:ะะซะกะะะงะะขะฌ{}, // ะะฐัะตะผ ัั ะฒััะบะพัะธะป ัะพ ัะฒะพะธะผ ะทะฐะผะตัะฐะฝะธะตะผ? (ะะซะกะะะงะะขะฌ ะก)
rus_verbs:ะะะกะขะ{}, // ะฟะปะพั ะฝะตัะปะพ ัะพ ัััะฐัะฝะพะน ัะธะปะพะน. (ะะะกะขะ ะก)
rus_verbs:ะฟัะธะฑะปะธะถะฐัััั{}, // ััะตะฝะฐ ะฟัะธะฑะปะธะถะฐะปะฐัั ัะพ ัััะฐัะฝะพะน ะฑััััะพัะพะน. (ะฟัะธะฑะปะธะถะฐัััั ั)
rus_verbs:ะทะฐะฝะธะผะฐัััั{}, // ะะพัะปะต ััะพะบะพะฒ ั ะทะฐะฝะธะผะฐะปัั ั ะพัััะฐััะธะผะธ ััะตะฝะธะบะฐะผะธ. (ะทะฐะฝะธะผะฐัััั ั)
rus_verbs:ัะฐะทัะฐะฑะพัะฐัั{}, // ะญัะพั ะปะตะบะฐัััะฒะตะฝะฝัะน ะฟัะตะฟะฐัะฐั ัะฐะทัะฐะฑะพัะฐะฝ ั ะธัะฟะพะปัะทะพะฒะฐะฝะธะตะผ ัะตัะตะฟัะพะฒ ััะฐะดะธัะธะพะฝะฝะพะน ะบะธัะฐะนัะบะพะน ะผะตะดะธัะธะฝั. (ัะฐะทัะฐะฑะพัะฐัั ั)
rus_verbs:ะฒะตััะธัั{}, // ะ ะฐะทัะฐะฑะพัะบะฐ ะผะตััะพัะพะถะดะตะฝะธั ะฒะตะดะตััั ั ะธัะฟะพะปัะทะพะฒะฐะฝะธะตะผ ะฑะพะปััะพะณะพ ะบะพะปะธัะตััะฒะฐ ัะตั
ะฝะธะบะธ. (ะฒะตััะธัั ั)
rus_verbs:ะบะพะฝัะปะธะบัะพะฒะฐัั{}, // ะะฐัะฐ ะบะพะฝัะปะธะบััะตั ั ะะตัะตะน (ะบะพะฝัะปะธะบัะพะฒะฐัั ั)
rus_verbs:ะผะตัะฐัั{}, // ะผะตัะฐัั ะฒะพะดั ั ะผัะบะพะน (ะผะตัะฐัั ั)
rus_verbs:ะธะผะตัั{}, // ะผะฝะต ัะถะต ะฟัะธั
ะพะดะธะปะพัั ะฝะตัะบะพะปัะบะพ ัะฐะท ะธะผะตัั ั ะฝะธะผ ะดะตะปะพ.
rus_verbs:ัะธะฝั
ัะพะฝะธะทะธัะพะฒะฐัั{}, // ัะธะฝั
ัะพะฝะธะทะธัะพะฒะฐัั ั ััะฐะปะพะฝะฝัะผ ะณะตะฝะตัะฐัะพัะพะผ
rus_verbs:ะทะฐัะธะฝั
ัะพะฝะธะทะธัะพะฒะฐัั{}, // ะทะฐัะธะฝั
ัะพะฝะธะทะธัะพะฒะฐัั ั ััะฐะปะพะฝะฝัะผ ะณะตะฝะตัะฐัะพัะพะผ
rus_verbs:ัะธะฝั
ัะพะฝะธะทะธัะพะฒะฐัััั{}, // ัะธะฝั
ัะพะฝะธะทะธัะพะฒะฐัััั ั ััะฐะปะพะฝะฝัะผ ะณะตะฝะตัะฐัะพัะพะผ
rus_verbs:ะทะฐัะธะฝั
ัะพะฝะธะทะธัะพะฒะฐัััั{}, // ะทะฐัะธะฝั
ัะพะฝะธะทะธัะพะฒะฐัััั ั ััะฐะปะพะฝะฝัะผ ะณะตะฝะตัะฐัะพัะพะผ
rus_verbs:ััะธัะฐัั{}, // ััะธัะฐัั ั ะผัะปะพะผ ััะฑะฐัะบั ะฒ ัะฐะทั
rus_verbs:ะฟััะณะฐัั{}, // ะฟะฐัะฐัััะธัั ะฟััะณะฐะตั ั ะฟะฐัะฐัััะพะผ
rus_verbs:ะฒััััะฟะธัั{}, // ะะฝ ะฒััััะฟะธะป ั ะฟัะธะฒะตัััะฒะธะตะผ ััะตะทะดั.
rus_verbs:ั
ะพะดะธัั{}, // ะ ััะถะพะน ะผะพะฝะฐััััั ัะพ ัะฒะพะธะผ ัััะฐะฒะพะผ ะฝะต ั
ะพะดัั.
rus_verbs:ะพัะพะทะฒะฐัััั{}, // ะะฝ ะพัะพะทะฒะฐะปัั ะพะฑ ััะพะน ะบะฝะธะณะต ั ะฑะพะปััะพะน ะฟะพั
ะฒะฐะปะพะน.
rus_verbs:ะพัะทัะฒะฐัััั{}, // ะะฝ ะพัะทัะฒะฐะตััั ะพะฑ ััะพะน ะบะฝะธะณะต ั ะฑะพะปััะพะน ะฟะพั
ะฒะฐะปะพะน.
rus_verbs:ะฒััะฐะฒะฐัั{}, // ะพะฝ ะฒััะฐัั ั ะทะฐััะน
rus_verbs:ะผะธัะธัั{}, // ะะณะพ ัะผ ะผะธัะธะป ะฒัะตั
ั ะตะณะพ ะดััะฝัะผ ั
ะฐัะฐะบัะตัะพะผ.
rus_verbs:ะฟัะพะดะพะปะถะฐัััั{}, // ัััะตะปัะฑะฐ ัะตะผ ะฒัะตะผะตะฝะตะผ ะฟัะพะดะพะปะถะฐะปะฐัั ั ะฟัะตะถะฝะตะน ัะพัะฝะพัััั.
rus_verbs:ะดะพะณะพะฒะพัะธัััั{}, // ะผั ะดะพะณะพะฒะพัะธะผัั ั ะฒะฐะผะธ
rus_verbs:ะฟะพะฑััั{}, // ะพะฝ ั
ะพัะตะป ะฟะพะฑััั ั ัะพะฑะพะน
rus_verbs:ัะฐััะธ{}, // ะะธัะพะฒัะต ะฟัะพะธะทะฒะพะดััะฒะตะฝะฝัะต ะผะพัะฝะพััะธ ัะฐัััั ั ะฑะตัะฟัะตัะตะดะตะฝัะฝะพะน ัะบะพัะพัััั
rus_verbs:ะฒัะทะฐัััั{}, // ะฒัะทะฐัััั ั ัะฐะบัะฐะผะธ
rus_verbs:ะพัะฝะตััะธัั{}, // ะพัะฝะตััะธัั ะบ ะถะธะฒะพัะฝัะผ ั ัะพััััะฒะธะตะผ
rus_verbs:ะพัะฝะพัะธัััั{}, // ะพัะฝะพัะธัััั ั ะฟะพะฝะธะผะฐะฝะธะตะผ
rus_verbs:ะฟะพะนัะธ{}, // ะกะฟะตะบัะฐะบะปั ะฟะพะนะดัั ั ััะฐััะธะตะผ ะธะทะฒะตััะฝัั
ะฐััะธััะพะฒ.
rus_verbs:ะฑัะฐะบะพัะพัะตัะฐัััั{}, // ะะพัะพะผััะฒะตะฝะฝัะน ะบัะทะฝะตั ะฑัะฐะบะพัะพัะตัะฐะปัั ั ัะฐะทะพัะธะฒัะตะนัั ะณัะฐัะธะฝะตะน
rus_verbs:ะณัะปััั{}, // ะฑะฐะฑััะบะฐ ะณัะปัะตั ั ะฒะฝัะบะพะผ
rus_verbs:ัะฐะทะฑะธัะฐัััั{}, // ัะฐะทะฑะธัะฐัััั ั ะทะฐะดะฐัะตะน
rus_verbs:ัะฒะตัะธัั{}, // ะะฐะฝะฝัะต ะฑัะปะธ ัะฒะตัะตะฝั ั ััะฐะปะพะฝะฝัะผะธ ะทะฝะฐัะตะฝะธัะผะธ
rus_verbs:ะดะตะปะฐัั{}, // ะงัะพ ะดะตะปะฐัั ัะพ ััะฐััะผ ัะตะปะตัะพะฝะพะผ
rus_verbs:ะพัะผะฐััะธะฒะฐัั{}, // ะพัะผะฐััะธะฒะฐัั ั ัะดะธะฒะปะตะฝะธะตะผ
rus_verbs:ะพะฑััะดะธัั{}, // ะพะฑััะดะธัั ั ะฟัะธััะตะปะตะผ ะฟัะพั
ะพะถะดะตะฝะธะต ััะพะฒะฝั ะฒ ะฝะพะฒะพะน ะธะณัะต
rus_verbs:ะฟะพะฟัะพัะฐัััั{}, // ะฟะพะฟัะพัะฐัััั ั ัะฐะปะฐะฝัะปะธะฒัะผ ะฐะบัะตัะพะผ
rus_verbs:ะทะฐะดัะตะผะฐัั{}, // ะทะฐะดัะตะผะฐัั ั ะบััะถะบะพะน ัะฐั ะฒ ััะบะต
rus_verbs:ัะฒัะทะฐัั{}, // ัะฒัะทะฐัั ะบะฐัะฐัััะพัั ั ะดะตะนััะฒะธัะผะธ ะบะพะฝะบััะตะฝัะพะฒ
rus_verbs:ะฝะพัะธัััั{}, // ะฝะพัะธัััั ั ะฑะตะทัะผะฝะพะน ะธะดะตะตะน
rus_verbs:ะบะพะฝัะฐัั{}, // ะบะพะฝัะฐัั ั ัะพะฑะพะน
rus_verbs:ะพะฑะผะตะฝะธะฒะฐัััั{}, // ะพะฑะผะตะฝะธะฒะฐัััั ั ัะพะฑะตัะตะดะฝะธะบะฐะผะธ
rus_verbs:ะฟะตัะตะณะพะฒะฐัะธะฒะฐัััั{}, // ะฟะตัะตะณะพะฒะฐัะธะฒะฐัััั ั ะผะฐัะบะพะผ
rus_verbs:ะพะฑัะฐัััั{}, // ะพะฑัะฐัััั ั ะฟะพะปะธัะธะตะน
rus_verbs:ะทะฐะฒะตััะธัั{}, // ะทะฐะฒะตััะธัั ั ะพัะธะฑะบะพะน
rus_verbs:ะพะฑะฝััััั{}, // ะพะฑะฝััััั ั ะฟะพะดััะณะพะน
rus_verbs:ัะปะธะฒะฐัััั{}, // ัะปะธะฒะฐัััั ั ัะพะฝะพะผ
rus_verbs:ัะผะตัะฐัััั{}, // ัะผะตัะฐัััั ั ัะพะปะฟะพะน
rus_verbs:ะดะพะณะพะฒะฐัะธะฒะฐัััั{}, // ะดะพะณะพะฒะฐัะธะฒะฐัััั ั ะฟะพัะตัะฟะตะฒัะธะผ
rus_verbs:ะพะฑะตะดะฐัั{}, // ะพะฑะตะดะฐัั ั ะณะพัััะผะธ
rus_verbs:ัะพะพะฑัะฐัััั{}, // ัะพะพะฑัะฐัััั ั ะฟะพะดะทะตะผะฝะพะน ัะตะบะพะน
rus_verbs:ััะฐะปะบะธะฒะฐัััั{}, // ััะฐะปะบะธะฒะฐัััั ัะพ ััะฐะตะน ะฟัะธั
rus_verbs:ัะธัะฐัััั{}, // ัะธัะฐัััั ั ัััะดะพะผ
rus_verbs:ัะผะธัะธัััั{}, // ัะผะธัะธัััั ั ัััะฐัะพะน
rus_verbs:ัะฐะทะดะตะปะธัั{}, // ัะฐะทะดะตะปะธัั ั ะดััะณะธะผะธ ะพัะฒะตัััะฒะตะฝะฝะพััั
rus_verbs:ัะพะดะฝะธัั{}, // ัะพะดะฝะธัั ั ะผะตะดะฒะตะดะตะผ
rus_verbs:ะผะตะดะปะธัั{}, // ะผะตะดะปะธัั ั ะพัะฒะตัะพะผ
rus_verbs:ัะบัะตััะธัั{}, // ัะบัะตััะธัั ั ัะถะพะผ
rus_verbs:ะฟะพะบะพะธัััั{}, // ะฟะพะบะพะธัััั ั ะผะธัะพะผ
rus_verbs:ะดะตะปะธัััั{}, // ะดะตะปะธัััั ั ะดััะทััะผะธ
rus_verbs:ะฟะพะทะฝะฐะบะพะผะธัั{}, // ะฟะพะทะฝะฐะบะพะผะธัั ั ะะปะตะน
rus_verbs:ะฟะพัะฒะฐัั{}, // ะฟะพัะฒะฐัั ั ะะปะตะน
rus_verbs:ะทะฐะฒัะทะฐัั{}, // ะทะฐะฒัะทะฐัั ั ะะปะตะน ะทะฝะฐะบะพะผััะฒะพ
rus_verbs:ััะตัะธัััั{}, // ััะตัะธัััั ั ะธะทะดะฐะฝะธะตะผ ัะพะผะฐะฝะฐ
rus_verbs:ัะพะตะดะธะฝะธัััั{}, // ัะพะตะดะธะฝะธัััั ั ัะตัะฒะตัะพะผ
rus_verbs:ัะฟัะฐะฒะปััััั{}, // ัะฟัะฐะฒะปััััั ั ะฝัะถะดะพะน
rus_verbs:ะทะฐะผะตัะบะฐัััั{}, // ะทะฐะผะตัะบะฐัััั ั ะพัะฒะตัะพะผ
rus_verbs:ะฟะพััะพัะธัััั{}, // ะฟะพััะพัะธัััั ั ะฟะพะดััะณะพะน
rus_verbs:ััะพัะธัััั{}, // ััะพัะธัััั ั ะดััะทััะผะธ
rus_verbs:ัะพัะพะฟะธัั{}, // ัะพัะพะฟะธัั ั ัะตัะตะฝะธะตะผ
rus_verbs:ะฟะพะทะดัะฐะฒะธัั{}, // ะฟะพะทะดัะฐะฒะธัั ั ะฟะพะฑะตะดะพะน
rus_verbs:ะฟัะพััะธัััั{}, // ะฟัะพััะธัััั ั ัะตะปะพะฒะตะบะพะผ
rus_verbs:ะฟะพัะฐะฑะพัะฐัั{}, // ะฟะพัะฐะฑะพัะฐัั ั ะดะตัะตะฒะพะผ
rus_verbs:ะฟัะธะบะปััะธัััั{}, // ะฟัะธะบะปััะธัััั ั ะะพะปะตะน
rus_verbs:ัะณะพะฒะพัะธัััั{}, // ัะณะพะฒะพัะธัััั ั ะะฐะฝะตะน
rus_verbs:ะพััะตั
ะฐัั{}, // ะพััะตั
ะฐัั ั ัะตะฒะพะผ
rus_verbs:ะพะฑัะตะดะธะฝััั{}, // ะพะฑัะตะดะธะฝััั ั ะดััะณะพะน ะบะฐะผะฟะฐะฝะธะตะน
rus_verbs:ัะฟะพััะตะฑะธัั{}, // ัะฟะพััะตะฑะธัั ั ะผะพะปะพะบะพะผ
rus_verbs:ะฟะตัะตะฟััะฐัั{}, // ะฟะตัะตะฟััะฐัั ั ะดััะณะพะน ะบะฝะธะณะพะน
rus_verbs:ะทะฐะฟะพะทะดะฐัั{}, // ะทะฐะฟะพะทะดะฐัั ั ะพัะฒะตัะพะผ
rus_verbs:ะฟะพะดััะถะธัััั{}, // ะฟะพะดััะถะธัััั ั ะดััะณะธะผะธ ะดะตััะผะธ
rus_verbs:ะดััะถะธัั{}, // ะดััะถะธัั ั ะกะตัะตะถะตะน
rus_verbs:ะฟะพัะฐะฒะฝััััั{}, // ะฟะพัะฐะฒะฝััััั ั ัะธะฝะธัะฝะพะน ัะตััะพะน
rus_verbs:ัะถะธะฝะฐัั{}, // ัะถะธะฝะฐัั ั ะณะพัััะผะธ
rus_verbs:ัะฐัััะฐะฒะฐัััั{}, // ัะฐัััะฐะฒะฐัััั ั ะฟัะธััะตะปัะผะธ
rus_verbs:ะทะฐะฒััะฐะบะฐัั{}, // ะทะฐะฒััะฐะบะฐัั ั ัะตะผัะตะน
rus_verbs:ะพะฑัะตะดะธะฝะธัััั{}, // ะพะฑัะตะดะธะฝะธัััั ั ัะพัะตะดัะผะธ
rus_verbs:ัะผะตะฝััััั{}, // ัะผะตะฝััััั ั ะฝะฐะฟะฐัะฝะธะบะพะผ
rus_verbs:ัะพะตะดะธะฝะธัั{}, // ัะพะตะดะธะฝะธัั ั ัะตััั
rus_verbs:ัะฐะทะณะพะฒะพัะธัััั{}, // ัะฐะทะณะพะฒะพัะธัััั ั ะพั
ัะฐะฝะฝะธะบะพะผ
rus_verbs:ะฟัะตะฟะพะดะฝะตััะธ{}, // ะฟัะตะฟะพะดะฝะตััะธ ั ะฟะพะผะฟะพะน
rus_verbs:ะฝะฐะฟะตัะฐัะฐัั{}, // ะฝะฐะฟะตัะฐัะฐัั ั ะบะฐััะธะฝะบะฐะผะธ
rus_verbs:ัะพะตะดะธะฝััั{}, // ัะพะตะดะธะฝััั ั ัะตััั
rus_verbs:ัะฐัะฟัะฐะฒะธัััั{}, // ัะฐัะฟัะฐะฒะธัััั ั ะฑะตะทะทะฐัะธัะฝัะผ ัะตะปะพะฒะตะบะพะผ
rus_verbs:ัะฐัะฟัะพัะฐัััั{}, // ัะฐัะฟัะพัะฐัััั ั ะดะตะฝัะณะฐะผะธ
rus_verbs:ััะฐะฒะฝะธัั{}, // ััะฐะฒะฝะธัั ั ะบะพะฝะบััะตะฝัะฐะผะธ
rus_verbs:ะพะทะฝะฐะบะพะผะธัััั{}, // ะพะทะฝะฐะบะพะผะธัััั ั ะฒััััะฟะปะตะฝะธะตะผ
ะธะฝัะธะฝะธัะธะฒ:ัะพัะตัะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะพัะตัะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ัะพัะตัะฐัััั ั ััะผะพัะบะพะน
ะดะตะตะฟัะธัะฐััะธะต:ัะพัะตัะฐััั{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะพัะตัะฐััะธะนัั{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะพัะตัะฐะฒัะธะนัั{},
rus_verbs:ะธะทะฝะฐัะธะปะพะฒะฐัั{}, // ะธะทะฝะฐัะธะปะพะฒะฐัั ั ะฟัะธะผะตะฝะตะฝะธะตะผ ััะตะทะฒััะฐะนะฝะพะณะพ ะฝะฐัะธะปะธั
rus_verbs:ะฟัะพัะฐัััั{}, // ะฟัะพัะฐัััั ั ะฑะพะตะฒัะผ ัะพะฒะฐัะธัะตะผ
rus_verbs:ััะฐะฒะฝะธะฒะฐัั{}, // ััะฐะฒะฝะธะฒะฐัั ั ะบะพะฝะบััะตะฝัะฐะผะธ
rus_verbs:ัะบะปะฐะดัะฒะฐัั{}, // ัะบะปะฐะดัะฒะฐัั ั ะฒะตัะพะผ ัะฟะฐะบะพะฒะบะธ
rus_verbs:ะฟะพะฒะตััะธัั{}, // ะฟะพะฒะตััะธัั ั ะฒะพัะฐะผะธ
rus_verbs:ััะพะปะบะฝััั{}, // ััะพะปะบะฝััั ั ะพัะฑะพะนะฝะธะบะพะผ
rus_verbs:ะฟะตัะตะณะปัะดัะฒะฐัััั{}, // ะฟะตัะตะณะปัะดัะฒะฐัััั ั ัะพัะตะดะพะผ
rus_verbs:ะฟะพัะพัะพะฟะธัั{}, // ะฟะพัะพัะพะฟะธัั ั ะพัะบะปะธะบะพะผ
rus_verbs:ัะฐะทะฒะปะตะบะฐัััั{}, // ัะฐะทะฒะปะตะบะฐัััั ั ะฟะพะดััะถะบะฐะผะธ
rus_verbs:ะทะฐะณะพะฒะฐัะธะฒะฐัั{}, // ะทะฐะณะพะฒะฐัะธะฒะฐัั ั ะฝะตะทะฝะฐะบะพะผัะฐะผะธ
rus_verbs:ะฟะพัะตะปะพะฒะฐัััั{}, // ะฟะพัะตะปะพะฒะฐัััั ั ะฟะตัะฒะพะน ะดะตะฒััะบะพะน
ะธะฝัะธะฝะธัะธะฒ:ัะพะณะปะฐัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะพะณะปะฐัะพะฒะฐัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ัะพะณะปะฐัะพะฒะฐัััั ั ะฟะพะดะปะตะถะฐัะธะผ
ะดะตะตะฟัะธัะฐััะธะต:ัะพะณะปะฐััััั{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะพะณะปะฐััััะธะนัั{},
rus_verbs:ัะพะฒะฟะฐััั{}, // ัะพะฒะฟะฐััั ั ะพัะธะณะธะฝะฐะปะพะผ
rus_verbs:ัะพะตะดะธะฝััััั{}, // ัะพะตะดะธะฝััััั ั ะบััะฐัะพัะพะผ
rus_verbs:ะฟะพะฒัััะตัะฐัััั{}, // ะฟะพะฒัััะตัะฐัััั ั ะณะตัะพัะผะธ
rus_verbs:ะฟะพัะถะธะฝะฐัั{}, // ะฟะพัะถะธะฝะฐัั ั ัะพะดะธัะตะปัะผะธ
rus_verbs:ัะฐะทะฒะตััะธัั{}, // ัะฐะทะฒะตััะธัั ั ะฟะตัะฒัะผ ะผัะถะตะผ
rus_verbs:ะฟะตัะตะณะพะฒะพัะธัั{}, // ะฟะตัะตะณะพะฒะพัะธัั ั ะบะพะปะปะตะณะฐะผะธ
rus_verbs:ััะตะฟะธัััั{}, // ััะตะฟะธัััั ั ะฑัะพะดััะตะน ัะพะฑะฐะบะพะน
rus_verbs:ัะพะถัะฐัั{}, // ัะพะถัะฐัั ั ะฟะพััะพั
ะฐะผะธ
rus_verbs:ะฟะพะฑะตัะตะดะพะฒะฐัั{}, // ะฟะพะฑะตัะตะดะพะฒะฐัั ัะพ ัะฟะฐะฝะพะน
rus_verbs:ะฟะพะธะณัะฐัั{}, // ะฟะพะธะณัะฐัั ั ะบะพัััะฐะผะธ
rus_verbs:ััะตะฟะธัั{}, // ััะตะฟะธัั ั ััะณะฐัะพะผ
rus_verbs:ะฟะพะผะธัะธัััั{}, // ะฟะพะผะธัะธัััั ั ะฟะพะดััะถะบะพะน
rus_verbs:ัะฒัะทัะฒะฐัััั{}, // ัะฒัะทัะฒะฐัััั ั ะฑะฐะฝะดะธัะฐะผะธ
rus_verbs:ัะพะฒะตัะฐัััั{}, // ัะพะฒะตัะฐัััั ั ะผะฐััะตัะฐะผะธ
rus_verbs:ะพะฑัััะธะฒะฐัััั{}, // ะพะฑัััะธะฒะฐัััั ั ะฑะตัะฟะพัะฐะดะฝะพะน ะบัะธัะธะบะพะน
rus_verbs:ะฟะตัะตะฟะปะตััะธัั{}, // ะฟะตัะตะฟะปะตััะธัั ั ะบัััะฐะผะธ
rus_verbs:ะผััะธัั{}, // ะผััะธัั ั ะพะดะฝะพะณััะฟะฝะธัะฐะผะธ
rus_verbs:ะฟัะธะณะปัะดัะฒะฐัััั{}, // ะฟัะธะณะปัะดัะฒะฐัััั ั ะธะฝัะตัะตัะพะผ
rus_verbs:ัะฑะปะธะทะธัััั{}, // ัะฑะปะธะทะธัััั ั ะฒัะฐะณะฐะผะธ
rus_verbs:ะฟะตัะตัะตะฟััะฒะฐัััั{}, // ะฟะตัะตัะตะฟััะฒะฐัััั ั ัะธะผะฟะฐัะธัะฝะพะน ัะพัะตะดะบะพะน
rus_verbs:ัะฐััะตัะตัั{}, // ัะฐััะตัะตัั ั ัะพะปัั
rus_verbs:ัะผะตัะธะฒะฐัััั{}, // ัะผะตัะธะฒะฐัััั ั ะธะทะฒะตัััั
rus_verbs:ัะพะฟัะธะบะพัะฝััััั{}, // ัะพะฟัะธะบะพัะฝััััั ั ัะฐะนะฝะพะน
rus_verbs:ะปะฐะดะธัั{}, // ะปะฐะดะธัั ั ัะพะดััะฒะตะฝะฝะธะบะฐะผะธ
rus_verbs:ัะพัััะดะฝะธัะฐัั{}, // ัะพัััะดะฝะธัะฐัั ั ะพัะณะฐะฝะฐะผะธ ะดะพะทะฝะฐะฝะธั
rus_verbs:ััะตั
ะฐัััั{}, // ััะตั
ะฐัััั ั ัะพะดััะฒะตะฝะฝะธะบะฐะผะธ
rus_verbs:ะฟะตัะตะบะธะฝััััั{}, // ะฟะตัะตะบะธะฝััััั ั ะบะพะปะปะตะณะฐะผะธ ะฟะฐัะพะน ัะปะพะฒ
rus_verbs:ัะพะฒะตัะพะฒะฐัััั{}, // ัะพะฒะตัะพะฒะฐัััั ั ะพััะธะผะพะผ
rus_verbs:ััะฐะฒะฝะธัััั{}, // ััะฐะฒะฝะธัััั ั ะปัััะธะผะธ
rus_verbs:ะทะฝะฐะบะพะผะธัััั{}, // ะทะฝะฐะบะพะผะธัััั ั ะฐะฑะธัััะธะตะฝัะฐะผะธ
rus_verbs:ะฝััััั{}, // ะฝััััั ั ะฐะบะฒะฐะปะฐะฝะณะพะผ
rus_verbs:ะทะฐะฑะฐะฒะปััััั{}, // ะทะฐะฑะฐะฒะปััััั ั ะบัะบะปะพะน
rus_verbs:ะฟะตัะตะบะปะธะบะฐัััั{}, // ะฟะตัะตะบะปะธะบะฐัััั ั ะดััะณะพะน ััะฐััะตะน
rus_verbs:ััะตะฝะธัะพะฒะฐัััั{}, // ััะตะฝะธัะพะฒะฐัััั ั ะฟะฐััะฝะตััะตะน
rus_verbs:ะฟะพัะฟะพัะธัั{}, // ะฟะพัะฟะพัะธัั ั ะบะฐะทะฝะพัะตะตะผ
ะธะฝัะธะฝะธัะธะฒ:ัะปะฐะดะธัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะปะฐะดะธัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะปะฐะดะธัั ั ะฑััะบะพะผ
ะดะตะตะฟัะธัะฐััะธะต:ัะปะฐะดะธะฒ{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะปะฐะดะธะฒัะธะน{ ะฒะธะด:ัะพะฒะตัั },
rus_verbs:ะฟัะธะผะธัะธัััั{}, // ะฟัะธะผะธัะธัััั ั ัััะฐัะพะน
rus_verbs:ัะฐัะบะปะฐะฝััััั{}, // ัะฐัะบะปะฐะฝััััั ั ััะตะนะปะธะฝะฐะผะธ
rus_verbs:ัะปะตัั{}, // ัะปะตัั ั ะฐะฝะณะธะฝะพะน
rus_verbs:ัะพะฟัะธะบะฐัะฐัััั{}, // ัะพะฟัะธะบะฐัะฐัััั ัะพ ััะตะฝะพะน
rus_verbs:ัะผะตัะฐัั{}, // ัะผะตัะฐัั ั ะณััะทัั
rus_verbs:ะฟะตัะตัะตะบะฐัััั{}, // ะฟะตัะตัะตะบะฐัััั ั ััะฐััะพะน
rus_verbs:ะฟััะฐัั{}, // ะฟััะฐัั ั ะณะพััะดะฐัััะฒะตะฝะฝะพะน ัะตััััั
rus_verbs:ะฟะพะฑะพะปัะฐัั{}, // ะฟะพะฑะพะปัะฐัั ั ััะตะฝะธัะฐะผะธ
rus_verbs:ะทะดะพัะพะฒะฐัััั{}, // ะทะดะพัะพะฒะฐัััั ั ะฟัะพัะตััะพัะพะผ
rus_verbs:ะฟัะพััะธัะฐัััั{}, // ะฟัะพััะธัะฐัััั ั ะฟะพะบัะฟะบะพะน
rus_verbs:ััะพัะพะถะธัั{}, // ััะพัะพะถะธัั ั ัะพะฑะฐะบะพะน
rus_verbs:ะพะฑััะบะธะฒะฐัั{}, // ะพะฑััะบะธะฒะฐัั ั ัะพะฑะฐะบะฐะผะธ
rus_verbs:ะฟะตัะตะฟะปะตัะฐัััั{}, // ะฟะตัะตะฟะปะตัะฐัััั ั ะดััะณะพะน ะฒะตัะบะพะน
rus_verbs:ะพะฑะฝะธะผะฐัััั{}, // ะพะฑะฝะธะผะฐัััั ั ะัััะตะน
rus_verbs:ะพะฑัะตะดะธะฝััััั{}, // ะพะฑัะตะดะธะฝััััั ั ะบะพะฝะบััะตะฝัะฐะผะธ
rus_verbs:ะฟะพะณะพัััะธัััั{}, // ะฟะพะณะพัััะธัััั ั ะฟะพะบัะฟะบะพะน
rus_verbs:ะผััััั{}, // ะผััััั ั ะผัะปะพะผ
rus_verbs:ัะฒะตัะธัััั{}, // ัะฒะตัะธัััั ั ััะฐะปะพะฝะพะผ
rus_verbs:ัะฐะทะดะตะปะฐัััั{}, // ัะฐะทะดะตะปะฐัััั ั ะบะตะผ-ัะพ
rus_verbs:ัะตัะตะดะพะฒะฐัััั{}, // ัะตัะตะดะพะฒะฐัััั ั ะฟะฐััะฝะตัะพะผ
rus_verbs:ะฝะฐะปะตัะตัั{}, // ะฝะฐะปะตัะตัั ั ัะพัะฐัะฝะธะบะฐะผะธ
rus_verbs:ะฟะพัะฟะฐัั{}, // ะฟะพัะฟะฐัั ั ะฒะบะปััะตะฝะฝัะผ ัะฒะตัะพะผ
rus_verbs:ัะฟัะฐะฒะธัััั{}, // ัะฟัะฐะฒะธัััั ั ัะพะฑะฐะบะพะน
rus_verbs:ัะพะณัะตัะธัั{}, // ัะพะณัะตัะธัั ั ะทะฐะผัะถะฝะตะน
rus_verbs:ะพะฟัะตะดะตะปะธัััั{}, // ะพะฟัะตะดะตะปะธัััั ั ะฟะพะฑะตะดะธัะตะปะตะผ
rus_verbs:ะฟะตัะตะผะตัะฐัััั{}, // ะฟะตัะตะผะตัะฐัััั ั ะณัะฐะฝัะปะฐะผะธ
rus_verbs:ะทะฐัััะดะฝััััั{}, // ะทะฐัััะดะฝััััั ั ะพัะฒะตัะพะผ
rus_verbs:ะพะฑะพะถะดะฐัั{}, // ะพะฑะพะถะดะฐัั ัะพ ััะฐััะพะผ
rus_verbs:ัััะบะฐัั{}, // ัััะบะฐัั ั ะฟัะตะทัะตะฝะธะตะผ
rus_verbs:ะทะฐัะธะดะตัััั{}, // ะทะฐัะธะดะตัััั ั ะฟัะธััะตะปะตะผ
rus_verbs:ะบัะตะฟะฝััั{}, // ะบัะตะฟะฝััั ั ะณะพะดะฐะผะธ
rus_verbs:ะฟะธัะพะฒะฐัั{}, // ะฟะธัะพะฒะฐัั ั ะดััะถะธะฝะพะน
rus_verbs:ัะตะฑะตัะฐัั{}, // ัะตะฑะตัะฐัั ั ัะตัััะธัะบะฐะผะธ
rus_verbs:ะผะฐััััั{}, // ะผะฐััััั ั ะบะฐัะปะตะผ
rus_verbs:ัะฑะปะธะถะฐัั{}, // ัะฑะปะธะถะฐัั ั ัะตะฝััะฐะปัะฝัะผ ัะฒะตัะธะปะพะผ
rus_verbs:ะผะตัะบะฝััั{}, // ะผะตัะบะฝััั ั ะฒะพะทัะฐััะพะผ
rus_verbs:ะทะฐัะฟะพัะธัั{}, // ะทะฐัะฟะพัะธัั ั ะพะฟะฟะพะฝะตะฝัะฐะผะธ
rus_verbs:ะณัะฐะฝะธัะธัั{}, // ะณัะฐะฝะธัะธัั ั ะะธะฒะฐะฝะพะผ
rus_verbs:ะฟะตัะตััะฐัะฐัััั{}, // ะฟะตัะตััะฐัะฐัััั ัะพ ััะธะผัะปััะพัะฐะผะธ
rus_verbs:ะพะฑัะตะดะธะฝะธัั{}, // ะพะฑัะตะดะธะฝะธัั ั ัะธะปะธะฐะปะพะผ
rus_verbs:ัะฒัะบะฝััััั{}, // ัะฒัะบะฝััััั ั ัััะฐัะพะน
rus_verbs:ะฟะพัะพะฒะตัะพะฒะฐัััั{}, // ะฟะพัะพะฒะตัะพะฒะฐัััั ั ะฐะดะฒะพะบะฐัะฐะผะธ
rus_verbs:ะฝะฐะฟััะฐัั{}, // ะฝะฐะฟััะฐัั ั ะฒะตะดะพะผะพัััะผะธ
rus_verbs:ะฝะฐะณััะฝััั{}, // ะฝะฐะณััะฝััั ั ะพะฑััะบะพะผ
rus_verbs:ะฟะพัะพะฒะตัะฐัััั{}, // ะฟะพัะพะฒะตัะฐัััั ั ััะดัะตะน
rus_verbs:ะฟัะพะฒะตัะฝััั{}, // ะฟัะพะฒะตัะฝััั ั ะดััะณะฐะฝะพะผ
rus_verbs:ัะฐะทะดะตะปััััั{}, // ัะฐะทะดะตะปััััั ั ัะพััะฐะฟะตะทะฝะธะบะฐะผะธ
rus_verbs:ะฟะตัะตัะตัััั{}, // ะฟะตัะตัะตัััั ั ะฒัะพัะพะน ะบะพะปะพะฝะฝะพะน
rus_verbs:ะพะฟะตัะตะถะฐัั{}, // ะพะฟะตัะตะถะฐัั ั ะฑะพะปััะธะผ ะทะฐะฟะฐัะพะผ
rus_verbs:ะฟะตัะตะฟััะฐัััั{}, // ะฟะตัะตะฟััะฐัััั ั ะดััะณะพะน ะปะธะฝะธะตะน
rus_verbs:ัะพะพัะฝะพัะธัััั{}, // ัะพะพัะฝะพัะธัััั ั ะทะฐััะฐัะฐะผะธ
rus_verbs:ัะผะตัะธะฒะฐัั{}, // ัะผะตัะธะฒะฐัั ั ะทะพะปะพะน
rus_verbs:ัะฒะธะดะตัััั{}, // ัะฒะธะดะตัััั ั ัะพะฑะพะน
rus_verbs:ะฟะตัะตัะฟะฐัั{}, // ะฟะตัะตัะฟะฐัั ั ะณัะฐัะธะฝะตะน
rus_verbs:ะฟะพะปะฐะดะธัั{}, // ะฟะพะปะฐะดะธัั ั ัะพัะตะดัะผะธ
rus_verbs:ะฟัะพัะฐัะธัั{}, // ะฟัะพัะฐัะธัั ั ัะพะฑะพะน
rus_verbs:ัะฐะทะผะธะฝััััั{}, // ัะฐะทะผะธะฝััััั ั ะฒัััะตัะฝัะผ ะฟะพัะพะบะพะผ
rus_verbs:ะฟะตัะตะผะตะถะฐัััั{}, // ะฟะตัะตะผะตะถะฐัััั ั ััะฟะตั
ะฐะผะธ
rus_verbs:ัะฐัััะธัะฐัััั{}, // ัะฐัััะธัะฐัััั ั ะบัะตะดะธัะพัะฐะผะธ
rus_verbs:ััะฐััะธัั{}, // ััะฐััะธัั ั ัะตะปะพะผ
rus_verbs:ะทะฝะฐะบะพะผะธัั{}, // ะทะฝะฐะบะพะผะธัั ั ัะพะดะธัะตะปัะผะธ
rus_verbs:ะฟะพััะณะฐัััั{}, // ะฟะพััะณะฐัััั ั ัะพะดะธัะตะปัะผะธ
rus_verbs:ัะพะฒะปะฐะดะฐัั{}, // ัะพะฒะปะฐะดะฐัั ั ััะฒััะฒะฐะผะธ
rus_verbs:ะพะฑัััะธัั{}, // ะพะฑัััะธัั ั ะฑะพะณะฐัะพะน ะฝะตะฒะตััะพะน
rus_verbs:ัะฑะปะธะถะฐัััั{}, // ัะฑะปะธะถะฐัััั ั ะฒัะฐะถะตัะบะธะผ ััะผะธะฝัะตะผ
rus_verbs:ะทะฐะผััะธัั{}, // ะทะฐะผััะธัั ั ะัััะตะน
rus_verbs:ะฟะพะฒะพะทะธัััั{}, // ะฟะพะฒะพะทะธัััั ั ะฝะฐัััะพะนะบะพะน
rus_verbs:ัะพัะณะพะฒะฐัััั{}, // ัะพัะณะพะฒะฐัััั ั ะฟัะพะดะฐะฒัะฐะผะธ
rus_verbs:ัะตะดะธะฝะธัััั{}, // ัะตะดะธะฝะธัััั ั ะดะตะฒัะพะฝะบะพะน
rus_verbs:ะฟะตัะตะฑะพััะธัั{}, // ะฟะตัะตะฑะพััะธัั ั ะดะพะฑะฐะฒะบะพะน
rus_verbs:ะพะทะฝะฐะบะพะผะธัั{}, // ะพะทะฝะฐะบะพะผะธัั ั ะฟะพะถะตะปะฐะฝะธัะผะธ
rus_verbs:ะฟัะพัะตััะฒะฐัั{}, // ะฟัะพัะตััะฒะฐัั ั ัะพะฑะฐะบะฐะผะธ
rus_verbs:ะฟะตัะตะฟะธััะฒะฐัััั{}, // ะฟะตัะตะฟะธััะฒะฐัััั ั ะบะพััะตัะฟะพะฝะดะตะฝัะฐะผะธ
rus_verbs:ะฟะพะฒะทะดะพัะธัั{}, // ะฟะพะฒะทะดะพัะธัั ั ัะตัะถะฐะฝัะพะผ
rus_verbs:ัะฐะทะปััะธัั{}, // ัะฐะทะปััะธัั ั ัะตะผัะตะน
rus_verbs:ัะพัะตะดััะฒะพะฒะฐัั{}, // ัะพัะตะดััะฒะพะฒะฐัั ั ััะณะฐะฝะฐะผะธ
rus_verbs:ะทะฐัััะบะฐัั{}, // ะทะฐัััะบะฐัั ั ะฟัะพััะธัััะบะฐะผะธ
rus_verbs:ะฝะฐะฟัััะธัััั{}, // ะฝะฐะฟัััะธัััั ั ะบัะปะฐะบะฐะผะธ
rus_verbs:ัะดััะถะธัััั{}, // ัะดััะถะธัััั ั ัะตะฑััะฐะผะธ
rus_verbs:ัะพะฟะตัะฝะธัะฐัั{}, // ัะพะฟะตัะฝะธัะฐัั ั ะฟะฐัะฐะปะปะตะปัะฝัะผ ะบะปะฐััะพะผ
rus_verbs:ะฟัะพัะตัะฐัั{}, // ะฟัะพัะตัะฐัั ั ัะพะฑะฐะบะฐะผะธ
rus_verbs:ะบะพะบะตัะฝะธัะฐัั{}, // ะบะพะบะตัะฝะธัะฐัั ั ะณะธะผะฝะฐะทะธััะบะฐะผะธ
rus_verbs:ะผะธัะธัััั{}, // ะผะธัะธัััั ั ัะฑััะบะฐะผะธ
rus_verbs:ะพะฟะปะพัะฐัั{}, // ะพะฟะปะพัะฐัั ั ะฑะธะปะตัะฐะผะธ
rus_verbs:ะพัะพะถะดะตััะฒะปััั{}, // ะพัะพะถะดะตััะฒะปััั ั ะปะธัะตัะฐัััะฝัะผ ะณะตัะพะตะผ
rus_verbs:ั
ะธััะธัั{}, // ั
ะธััะธัั ั ะทะฐัะฟะปะฐัะพะน
rus_verbs:ะฟัะพะฒะพะทะธัััั{}, // ะฟัะพะฒะพะทะธัััั ั ะทะฐะดะฐัะบะพะน
rus_verbs:ะบะพัะพัะฐัั{}, // ะบะพัะพัะฐัั ั ะดััะทััะผะธ
rus_verbs:ัะพัะตะฒะฝะพะฒะฐัััั{}, // ัะพัะตะฒะฝะพะฒะฐัััั ั ะผะฐัะธะฝะพะน
rus_verbs:ัะถะธะฒะฐัััั{}, // ัะถะธะฒะฐัััั ั ะผะตััะฝัะผะธ ะถะธัะตะปัะผะธ
rus_verbs:ะพัะพะถะดะตััะฒะปััััั{}, // ะพัะพะถะดะตััะฒะปััััั ั ะปะธัะตัะฐัััะฝัะผ ะณะตัะพะตะผ
rus_verbs:ัะพะฟะพััะฐะฒะธัั{}, // ัะพะฟะพััะฐะฒะธัั ั ััะฐะปะพะฝะพะผ
rus_verbs:ะฟััะฝััะฒะพะฒะฐัั{}, // ะฟััะฝััะฒะพะฒะฐัั ั ะดััะทััะผะธ
rus_verbs:ะทะฐะปะตัะฐัั{}, // ะทะฐะปะตัะฐัั ั ะฟะฐะปะตะฝะพะน ะฒะพะดะบะพะน
rus_verbs:ะณะฐัััะพะปะธัะพะฒะฐัั{}, // ะณะฐัััะพะปะธัะพะฒะฐัั ั ะฝะพะฒะพะน ัะธัะบะพะฒะพะน ะฟัะพะณัะฐะผะผะพะน
rus_verbs:ะทะฐะฟะฐะทะดัะฒะฐัั{}, // ะทะฐะฟะฐะทะดัะฒะฐัั ั ะบะพัะผะปะตะฝะธะตะผ
rus_verbs:ัะฐัะบะฐัััั{}, // ัะฐัะบะฐัััั ั ััะผะบะฐะผะธ
rus_verbs:ะบะพะฝััะฐััะธัะพะฒะฐัั{}, // ะบะพะฝััะฐััะธัะพะฒะฐัั ั ัััะปัะผะธ
rus_verbs:ััะธะฑะธัััั{}, // ััะธะฑะธัััั ั ัะพัะฒะฐัะดะพะผ
rus_verbs:ัะพัััะทะฐัััั{}, // ัะพัััะทะฐัััั ั ะปัััะตะน ะบะพะผะฐะฝะดะพะน
rus_verbs:ะทะฐัััะดะฝะธัััั{}, // ะทะฐัััะดะฝะธัััั ั ะพะฑัััะฝะตะฝะธะตะผ
rus_verbs:ะพะฑัััะฝะธัััั{}, // ะพะฑัััะฝะธัััั ั ะฟะพัััะฐะดะฐะฒัะธะผะธ
rus_verbs:ัะฐะทะฒะพะดะธัััั{}, // ัะฐะทะฒะพะดะธัััั ัะพ ัะฒะฐัะปะธะฒะพะน ะถะตะฝะพะน
rus_verbs:ะฟัะตะฟะธัะฐัััั{}, // ะฟัะตะฟะธัะฐัััั ั ะฐะดะฒะพะบะฐัะฐะผะธ
rus_verbs:ัะพัััะตััะฒะพะฒะฐัั{}, // ัะพัััะตััะฒะพะฒะฐัั ั ะบััะฟะฝัะผะธ ั
ะธัะฝะธะบะฐะผะธ
rus_verbs:ัะฒะตััะธัั{}, // ัะฒะตััะธัั ั ะฝัะปะตะฒัะผ ััะตัะพะผ
rus_verbs:ะพะฑะณะพะฒะพัะธัั{}, // ะพะฑะณะพะฒะพัะธัั ั ะดะธัะตะบัะพัะพะผ
rus_verbs:ะพะฑะฒะตะฝัะฐัััั{}, // ะพะฑะฒะตะฝัะฐัััั ั ะฒะตะดัะผะพะน
rus_verbs:ัะบัะฟะตัะธะผะตะฝัะธัะพะฒะฐัั{}, // ัะบัะฟะตัะธะผะตะฝัะธัะพะฒะฐัั ั ะณะตะฝะฐะผะธ
rus_verbs:ัะฒะตัััั{}, // ัะฒะตัััั ั ัะฐะฑะปะธัะตะน
rus_verbs:ัะฒะตัััััั{}, // ัะฒะตัะธัััั ั ัะฐะฑะปะธัะตะน
rus_verbs:ัะฑะปะธะทะธัั{}, // ัะฑะปะธะทะธัั ั ัะพัะบะพะน
rus_verbs:ะณะฐัะผะพะฝะธัะพะฒะฐัั{}, // ะณะฐัะผะพะฝะธัะพะฒะฐัั ั ะพะฑะพัะผะธ
rus_verbs:ะฟะตัะตะผะตัะธะฒะฐัั{}, // ะฟะตัะตะผะตัะธะฒะฐัั ั ะผะพะปะพะบะพะผ
rus_verbs:ััะตะฟะฐัััั{}, // ััะตะฟะฐัััั ั ัะพัะปัะถะธะฒัะฐะผะธ
rus_verbs:ะฟะตัะตะผะธะณะธะฒะฐัััั{}, // ะฟะตัะตะผะธะณะธะฒะฐัััั ั ัะพัะตะดะบะพะน
rus_verbs:ัะฐะทะพัะบัะพะฒะตะฝะฝะธัะฐัััั{}, // ัะฐะทะพัะบัะพะฒะตะฝะฝะธัะฐัััั ั ะฝะตะทะฝะฐะบะพะผัะตะผ
rus_verbs:ัะฐัะฟะธัั{}, // ัะฐัะฟะธัั ั ัะพะฑัััะปัะฝะธะบะฐะผะธ
rus_verbs:ัะบัะตััะธัั{}, // ัะบัะตััะธัั ั ะดะธะบะพะน ะปะพัะฐะดัั
rus_verbs:ะฟะตัะตะดัะฐัััั{}, // ะฟะตัะตะดัะฐัััั ั ะดะฒะพัะพะฒัะผะธ ัะพะฑะฐะบะฐะผะธ
rus_verbs:ัะผััั{}, // ัะผััั ั ะผัะปะพะผ
rus_verbs:ะณััะทัััั{}, // ะณััะทัััั ั ัะพัะตะดัะผะธ
rus_verbs:ะฟะตัะตััะณะธะฒะฐัััั{}, // ะฟะตัะตััะณะธะฒะฐัััั ั ัะพัะตะดัะผะธ
rus_verbs:ะดะพะธะณัะฐัััั{}, // ะดะพะธะณัะฐัััั ัะพ ัะฟะธัะบะฐะผะธ
rus_verbs:ะทะฐะปะฐะดะธัััั{}, // ะทะฐะปะฐะดะธัััั ั ะฟะพะดััะณะพะน
rus_verbs:ัะบัะตัะธะฒะฐัััั{}, // ัะบัะตัะธะฒะฐัััั ั ะดะธะบะธะผะธ ะฒะธะดะฐะผะธ
rus_verbs:ะฟะพะฒะธะดะฐัััั{}, // ะฟะพะฒะธะดะฐัััั ั ะดะตะดััะบะพะน
rus_verbs:ะฟะพะฒะพะตะฒะฐัั{}, // ะฟะพะฒะพะตะฒะฐัั ั ะพัะบะฐะผะธ
rus_verbs:ััะฐะทะธัััั{}, // ััะฐะทะธัััั ั ะปัััะธะผ ัััะฐัะตะผ
rus_verbs:ะบะธะฟััะธัั{}, // ะบะธะฟััะธัั ั ะพัะฑะตะปะธะฒะฐัะตะปะตะผ
rus_verbs:ััะตัะดััะฒะพะฒะฐัั{}, // ััะตัะดััะฒะพะฒะฐัั ั ะฝะฐะบะฐะทะฐะฝะธะตะผ
rus_verbs:ัั
ะปะตััะฝััััั{}, // ัั
ะปะตััะฝััััั ั ะปัััะธะผ ะฑะพะบัะตัะพะผ
rus_verbs:ะฟะพัะตะฟัะฐัััั{}, // ะฟะพัะตะฟัะฐัััั ั ััะดััะผะธ
rus_verbs:ััะฐะฒะฝััััั{}, // ััะฐะฒะฝััััั ั ะปัััะธะผะธ ัะบะทะตะผะฟะปััะฐะผะธ
rus_verbs:ัะตัะตะผะพะฝะธัััั{}, // ัะตัะตะผะพะฝะธัััั ั ะฟััะฝะธัะฐะผะธ
rus_verbs:ะบะพะฝััะปััะธัะพะฒะฐัััั{}, // ะบะพะฝััะปััะธัะพะฒะฐัััั ัะพ ัะฟะตัะธะฐะปะธััะฐะผะธ
rus_verbs:ะฟะตัะตััะตัะดััะฒะพะฒะฐัั{}, // ะฟะตัะตััะตัะดััะฒะพะฒะฐัั ั ะฝะฐะบะฐะทะฐะฝะธะตะผ
rus_verbs:ะฟัะพะฝะพัะธัััั{}, // ะฟัะพะฝะพัะธัััั ั ัะพะฑะพะน
rus_verbs:ะฟะตัะตะผะตัะฐัั{}, // ะฟะตัะตะผะตัะฐัั ั ะณะธะฟัะพะผ
rus_verbs:ัะตะผะฝะธัั{}, // ัะตะผะฝะธัั ั ะดะพะปะณะฐะผะธ
rus_verbs:ััะฐะปะบะธะฒะฐัั{}, // ััะฐะปะบะธะฒะฐัั ั ัะตัะฝะพะน ะดััะพะน
rus_verbs:ัะฒะพะปัะฝััั{}, // ัะฒะพะปัะฝััั ั ะฒะพะปััะธะผ ะฑะธะปะตัะพะผ
rus_verbs:ะทะฐะธะณััะฒะฐัั{}, // ะทะฐะธะณััะฒะฐัั ั ัะพะฒะตััะตะฝะฝะพ ะดะธะบะธะผ ะถะธะฒะพัะฝัะผ
rus_verbs:ัะพะฟะพััะฐะฒะปััั{}, // ัะพะฟะพััะฐะฒะปััั ั ััะฐะปะพะฝะฝัะผะธ ะพะฑัะฐะทัะฐะผะธ
rus_verbs:ัะฐััะพัะณะฝััั{}, // ัะฐััะพัะณะฝััั ั ะฝะตัะฐััะพัะพะฟะฝัะผะธ ะฟะพััะฐะฒัะธะบะฐะผะธ ะดะพะปะณะพััะพัะฝัะน ะบะพะฝััะฐะบั
rus_verbs:ัะพะทะฒะพะฝะธัััั{}, // ัะพะทะฒะพะฝะธัััั ั ะผะฐะผะพะน
rus_verbs:ัะฟะตัััั{}, // ัะฟะตัััั ั ะพัััะฒะปะตะฝะฝัะผะธ ั
ัะปะธะณะฐะฝะฐะผะธ
rus_verbs:ะธะฝััะธะณะพะฒะฐัั{}, // ะธะฝััะธะณะพะฒะฐัั ั ะฟัะธะดะฒะพัะฝัะผะธ
rus_verbs:ะฟัะธะพะฑัะตััะธ{}, // ะฟัะธะพะฑัะตััะธ ัะพ ัะบะธะดะบะพะน
rus_verbs:ะทะฐะดะตัะถะฐัััั{}, // ะทะฐะดะตัะถะฐัััั ัะพ ัะดะฐัะตะน ัะฐะฑะพัั
rus_verbs:ะฟะปะฐะฒะฐัั{}, // ะฟะปะฐะฒะฐัั ัะพ ัะฟะฐัะฐัะตะปัะฝัะผ ะบััะณะพะผ
rus_verbs:ัะบัะฐัััั{}, // ะะต ัะบัะฐะนัั ั ะฒัะฐะณะฐะผะธ
ะธะฝัะธะฝะธัะธะฒ:ะฐััะพัะธะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั}, // ัะธัะฐัะตะปะธ ะฐััะพัะธะธัััั ั ัะพะฑะพะน ะณะตัะพั ะบะฝะธะณะธ
ะธะฝัะธะฝะธัะธะฒ:ะฐััะพัะธะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฐััะพัะธะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั}, // ัะธัะฐัะตะปะธ ะฐััะพัะธะธัััั ั ัะพะฑะพะน ะณะตัะพั ะบะฝะธะณะธ
ะณะปะฐะณะพะป:ะฐััะพัะธะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
//+ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐััะพัะธะธัะพะฒะฐะฒัะธะน{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐััะพัะธะธัะพะฒะฐะฒัะธะน{ะฒะธะด:ัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐััะพัะธะธััััะธะน{},
ะดะตะตะฟัะธัะฐััะธะต:ะฐััะพัะธะธััั{},
ะดะตะตะฟัะธัะฐััะธะต:ะฐััะพัะธะธัะพะฒะฐะฒ{},
rus_verbs:ะฐััะพัะธะธัะพะฒะฐัััั{}, // ะณะตัะพะน ะบะฝะธะณะธ ะฐััะพัะธะธััะตััั ั ัะตะฐะปัะฝัะผ ะฟะตััะพะฝะฐะถะตะผ
rus_verbs:ะฐััะตััะพะฒัะฒะฐัั{}, // ะะฝะธ ะฐััะตััะพะฒัะฒะฐัั ัะพัััะดะฝะธะบะพะฒ ั ะฟะพะผะพััั ะฝะฐะฑะพััะฐ ัะตััะพะฒ
rus_verbs:ะฐััะตััะพะฒัะฒะฐัััั{}, // ะกะพัััะดะฝะธะบะธ ะฐััะตััะพะฒัะฒะฐัััั ั ะฟะพะผะพััั ะฝะฐะฑะพัะฐ ัะตััะพะฒ
//+ะธะฝัะธะฝะธัะธะฒ:ะฐััะธะปะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั}, // ััะธ ะฟัะตะดะฟัะธััะธั ะฑัะปะธ ะฐััะธะปะธัะพะฒะฐะฝั ั ะพะปะธะณะฐัั
ะพะผ
//+ะณะปะฐะณะพะป:ะฐััะธะปะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐััะธะปะธัะพะฒะฐะฝะฝัะน{},
rus_verbs:ะฑะฐะปะพะฒะฐัััั{}, // ะผะฐะปััะธะบ ะฑะฐะปะพะฒะฐะปัั ั ะผะพะปะพัะบะพะผ
rus_verbs:ะฑะฐะปััะฝะธัะฐัั{}, // ะถะตะฝัะธะฝะฐ ะฑะฐะปััะฝะธัะฐะปะฐ ั ัะพะฒะฐัะบะฐะผะธ
rus_verbs:ะฑะพะณะฐัะตัั{}, // ะัะพะฒะธะฝัะธั ะฑะพะณะฐัะตะตั ะพั ัะพัะณะพะฒะปะธ ั ัะพัะตะดัะผะธ
rus_verbs:ะฑะพะดะฐัััั{}, // ัะตะปะตะฝะพะบ ะฑะพะดะฐะตััั ั ะดะตัะตะฒะพะผ
rus_verbs:ะฑะพะบัะธัะพะฒะฐัั{}, // ะะฐะนะบะป ะดะฒะฐะถะดั ะฑะพะบัะธัะพะฒะฐะป ั ะฝะธะผ
rus_verbs:ะฑัะฐัะฐัััั{}, // ะกะพะปะดะฐัั ะฑัะฐัะฐะปะธัั ั ะฑะพะนัะฐะผะธ ัะพัะทะฝะธะบะพะฒ
rus_verbs:ะฒะฐะปััะธัะพะฒะฐัั{}, // ะะฐะปััะธะบ ะฒะฐะปััะธััะตั ั ะดะตะฒะพัะบะพะน
rus_verbs:ะฒะฒะตััััะฒะฐัั{}, // ะะธะทะฐะนะฝะตั ั ัััะดะพะผ ะฒะฒะตััััะฒะฐะตั ะฑะปะพะบะธ ะฒ ัััะฐะฝะธัั
rus_verbs:ะฟัะพะธัั
ะพะดะธัั{}, // ะงัะพ ะฟัะพะธัั
ะพะดะธั ั ะผะธัะพะฒะพะน ัะบะพะฝะพะผะธะบะพะน?
rus_verbs:ะฟัะพะธะทะพะนัะธ{}, // ะงัะพ ะฟัะพะธะทะพัะปะพ ั ัะบะพะฝะพะผะธะบะพะน?
rus_verbs:ะฒะทะฐะธะผะพะดะตะนััะฒะพะฒะฐัั{}, // ะญะปะตะบััะพะฝั ะฒะทะฐะธะผะพะดะตะนััะฒััั ั ัะพัะพะฝะฐะผะธ
rus_verbs:ะฒะทะดะพัะธัั{}, // ะญัะฐ ะถะตะฝัะธะฝะฐ ัะฐััะพ ะฒะทะดะพัะธะปะฐ ั ัะพัะตะดัะผะธ
rus_verbs:ัะพะนัะธัั{}, // ะะฐะปััะธะบ ัะพัะตะปัั ั ะฑะฐะฝะดะพะน ั
ัะปะธะณะฐะฝะพะฒ
rus_verbs:ะฒะพะฑัะฐัั{}, // ะฒะพะฑัะฐัั ะฒ ัะตะฑั ะปัััะธะต ะผะตัะพะดั ะฑะพััะฑั ั ะฒัะตะดะธัะตะปัะผะธ
rus_verbs:ะฒะพะดะธัััั{}, // ะัะฝั ะฒะพะดะธััั ั ะดะตััะผะธ
rus_verbs:ะฒะพะตะฒะฐัั{}, // ะคะตัะผะตัั ะฒะพะตะฒะฐะปะธ ั ะฒะพะปะบะฐะผะธ
rus_verbs:ะฒะพะทะธัััั{}, // ะัะฝั ะฒะพะทะธััั ั ะดะตััะผะธ
rus_verbs:ะฒะพัะบะพะฒะฐัั{}, // ะะพะปัะฑั ะฒะพัะบัะตั ั ะณะพะปัะฑะบะพะน
rus_verbs:ะฒะพััะพะตะดะธะฝะธัััั{}, // ะะตัะธ ะฒะพััะพะตะดะธะฝะธะปะธัั ั ัะตะผัะตะน
rus_verbs:ะฒะพััะพะตะดะธะฝััััั{}, // ะะตัะธ ะฒะพััะพะตะดะธะฝััััั ั ัะตะผัะตะน
rus_verbs:ะฒะพัะบะฐัััั{}, // ะะต ะฒะพัะบะฐะนัั ั ััะพะน ะตััะฝะดะพะน
rus_verbs:ะฒัะฐะถะดะพะฒะฐัั{}, // ะฒัะฐะถะดะพะฒะฐัั ั ัะพัะตะดัะผะธ
rus_verbs:ะฒัะตะผะตะฝะธัั{}, // ะฒัะตะผะตะฝะธัั ั ะฒัั
ะพะดะพะผ ะฝะฐ ะฟะตะฝัะธั
rus_verbs:ัะฐัััะฐัััั{}, // ั ะฝะต ะผะพะณั ัะฐัััะฐัััั ั ัะพะฑะพะน
rus_verbs:ะฒัะดะธัะฐัั{}, // ะฒัะดะธัะฐัั ั ะผััะพะผ
rus_verbs:ะฒัะดะธัะฐัััั{}, // ะฒัะดะธัะฐัััั ั ะผััะพะผ
rus_verbs:ะฒััะฒะพัะธัั{}, // ะฒััะฒะพัะธัั ััะพ-ะปะธะฑะพ ั ัะตะผ-ะปะธะฑะพ
rus_verbs:ะฒััะฒะพัััั{}, // ะฒััะฒะพัััั ััะพ-ะปะธะฑะพ ั ัะตะผ-ะปะธะฑะพ
rus_verbs:ัะดะตะปะฐัั{}, // ัะดะตะปะฐัั ั ัะตะผ-ัะพ
rus_verbs:ะดะพะผััั{}, // ะดะพะผััั ั ะผัะปะพะผ
rus_verbs:ัะปััะธัััั{}, // ัะปััะธัััั ั ะบะตะผ-ัะพ
rus_verbs:ะพััะฐัััั{}, // ะพััะฐัััั ั ะบะตะผ-ัะพ
rus_verbs:ัะปััะฐัั{}, // ัะปััะฐัั ั ะฟะพัะพะดะธัััะผ ะบะพะฑะตะปัะบะพะผ
rus_verbs:ะฟะพัะปะฐัั{}, // ะฟะพัะปะฐัั ั ะฒะตััะพัะบะพะน
rus_verbs:ัะฐะฑะพัะฐัั{}, // ัะฐะฑะพัะฐัั ั ัะพะฑะพัะฐะผะธ
rus_verbs:ะฟัะพะฒะตััะธ{}, // ะฟัะพะฒะตััะธ ั ะดะตะฒัะพะฝะบะฐะผะธ ะฒัะตะผั
rus_verbs:ะทะฐะณะพะฒะพัะธัั{}, // ะทะฐะณะพะฒะพัะธัั ั ะฝะตะทะฝะฐะบะพะผะบะพะน
rus_verbs:ะฟัะพัะตะฟัะฐัั{}, // ะฟัะพัะตะฟัะฐัั ั ะฟัะธะดัั
ะฐะฝะธะตะผ
rus_verbs:ัะธัะฐัั{}, // ัะธัะฐัั ั ะฒััะฐะถะตะฝะธะตะผ
rus_verbs:ัะปััะฐัั{}, // ัะปััะฐัั ั ะฟะพะฒััะตะฝะฝัะผ ะฒะฝะธะผะฐะฝะธะตะผ
rus_verbs:ะฟัะธะฝะตััะธ{}, // ะฟัะธะฝะตััะธ ั ัะพะฑะพะน
rus_verbs:ัะฟะฐัั{}, // ัะฟะฐัั ั ะถะตะฝัะธะฝะฐะผะธ
rus_verbs:ะทะฐะบะพะฝัะธัั{}, // ะทะฐะบะพะฝัะธัั ั ะฟัะธะณะพัะพะฒะปะตะฝะธัะผะธ
rus_verbs:ะฟะพะผะพัั{}, // ะฟะพะผะพัั ั ะฟะตัะตััะฐะฝะพะฒะบะพะน
rus_verbs:ัะตั
ะฐัั{}, // ัะตั
ะฐัั ั ัะตะผัะตะน
rus_verbs:ัะปััะฐัััั{}, // ัะปััะฐัััั ั ะบะตะผ-ัะพ
rus_verbs:ะบััะธัั{}, // ะบััะธัั ั ะฟัะพััะธัััะบะฐะผะธ
rus_verbs:ัะฐะทะณะพะฒะฐัะธะฒะฐัั{}, // ัะฐะทะณะพะฒะฐัะธะฒะฐัั ั ัะตะฑะตะฝะบะพะผ
rus_verbs:ะฟะพะณะพะดะธัั{}, // ะฟะพะณะพะดะธัั ั ะปะธะบะฒะธะดะฐัะธะตะน
rus_verbs:ััะธัะฐัััั{}, // ััะธัะฐัััั ั ััะถะธะผ ะผะฝะตะฝะธะตะผ
rus_verbs:ะฝะพัะธัั{}, // ะฝะพัะธัั ั ัะพะฑะพะน
rus_verbs:ั
ะพัะพัะตัั{}, // ั
ะพัะพัะตัั ั ะบะฐะถะดัะผ ะดะฝะตะผ
rus_verbs:ะฟัะธะฒะพะดะธัั{}, // ะฟัะธะฒะพะดะธัั ั ัะพะฑะพะน
rus_verbs:ะฟััะณะฝััั{}, // ะฟััะณะฝััั ั ะฟะฐัะฐัััะพะผ
rus_verbs:ะฟะตัั{}, // ะฟะตัั ั ััะฒััะฒะพะผ
rus_verbs:ัะปะพะถะธัั{}, // ัะปะพะถะธัั ั ัะตะทัะปััะฐัะพะผ
rus_verbs:ะฟะพะทะฝะฐะบะพะผะธัััั{}, // ะฟะพะทะฝะฐะบะพะผะธัััั ั ะดััะณะธะผะธ ัััะดะตะฝัะฐะผะธ
rus_verbs:ะพะฑัะฐัะฐัััั{}, // ะพะฑัะฐัะฐัััั ั ะถะธะฒะพัะฝัะผะธ
rus_verbs:ััะตััั{}, // ััะตััั ั ั
ะปะตะฑะพะผ
rus_verbs:ะพัะธะฑะฐัััั{}, // ะพัะธะฑะฐัััั ั ะดะพะทะธัะพะฒะบะพะน
rus_verbs:ััะพะปะบะฝััััั{}, // ััะพะปะบะฝััััั ั ะผะตะดะฒะตะดะตะผ
rus_verbs:ัะฟัะฐะฒะธัััั{}, // ัะฟัะฐะฒะธัััั ั ะฝัะถะดะพะน
rus_verbs:ัะพัะพะฟะธัััั{}, // ัะพัะพะฟะธัััั ั ะพัะฒะตัะพะผ
rus_verbs:ะฟะพะทะดัะฐะฒะปััั{}, // ะฟะพะทะดัะฐะฒะปััั ั ะฟะพะฑะตะดะพะน
rus_verbs:ะพะฑัััะฝััััั{}, // ะพะฑัััะฝััััั ั ะฝะฐัะฐะปัััะฒะพะผ
rus_verbs:ะฟะพัััะธัั{}, // ะฟะพัััะธัั ั ะฟะพะดััะณะพะน
rus_verbs:ะฟะพะทะดะพัะพะฒะฐัััั{}, // ะฟะพะทะดะพัะพะฒะฐัััั ั ะบะพะปะปะตะณะฐะผะธ
rus_verbs:ะฟะพัััะฟะฐัั{}, // ะะฐะบ ะฟะพัััะฟะฐัั ั ัะฐะบะธะผ ะฟะพะฒะตะดะตะฝะธะตะผ?
rus_verbs:ะพะฟัะตะดะตะปััััั{}, // ะพะฟัะตะดะตะปััััั ั ะบะฐะฝะดะธะดะฐัะฐะผะธ
rus_verbs:ัะฒัะทะฐัััั{}, // ัะฒัะทะฐัััั ั ะฟะพััะฐะฒัะธะบะพะผ
rus_verbs:ัะฟะพัะธัั{}, // ัะฟะพัะธัั ั ัะพะฑะตัะตะดะฝะธะบะพะผ
rus_verbs:ัะฐะทะพะฑัะฐัััั{}, // ัะฐะทะพะฑัะฐัััั ั ะดะตะปะฐะผะธ
rus_verbs:ะปะพะฒะธัั{}, // ะปะพะฒะธัั ั ัะดะพัะบะพะน
rus_verbs:ะฟะพะผะตะดะปะธัั{}, // ะะฐะฝะดะธะดะฐั ะฟะพะผะตะดะปะธะป ั ะพัะฒะตัะพะผ ะฝะฐ ะทะฐะดะฐะฝะฝัะน ะฒะพะฟัะพั
rus_verbs:ัััะธัั{}, // ัััะธัั ั ะดะธะบะธะผ ะทะฒะตัะตะผ
rus_verbs:ัะฐะทะพัะฒะฐัั{}, // ัะฐะทะพัะฒะฐัั ั ะฟะพััะฐะฒัะธะบะพะผ ะบะพะฝััะฐะบั
rus_verbs:ัะฒะตะทัะธ{}, // ัะฒะตะทัะธ ั ัะพะฑะพะน
rus_verbs:ัะฝะตััะธ{}, // ัะฝะตััะธ ั ัะพะฑะพะน
rus_verbs:ัะพัะฒะพัะธัั{}, // ัะพัะฒะพัะธัั ั ัะพะฑะพะน ััะพ-ัะพ ะฝะตั
ะพัะพัะตะต
rus_verbs:ัะบะปะฐะดัะฒะฐัััั{}, // ัะบะปะฐะดัะฒะฐัััั ั ะฟะตัะฒัะผ ะธะผะฟัะปััะพะผ
rus_verbs:ัะพะณะปะฐัะฐัััั{}, // ัะพะณะปะฐัะฐัััั ั ะฟัะตะดะปะพะถะตะฝะฝัะผ ะดะพะณะพะฒะพัะพะผ
//rus_verbs:ะฟะพะบะพะฝัะธัั{}, // ะฟะพะบะพะฝัะธัั ั ัะฐะทะฒัะฐัะพะผ
rus_verbs:ะฟัะธั
ะฒะฐัะธัั{}, // ะฟัะธั
ะฒะฐัะธัั ั ัะพะฑะพะน
rus_verbs:ะฟะพั
ะพัะพะฝะธัั{}, // ะฟะพั
ะพัะพะฝะธัั ั ะฟะพัะตัััะผะธ
rus_verbs:ัะฒัะทัะฒะฐัั{}, // ัะฒัะทัะฒะฐัั ั ะบะพะผะฟะฐะฝะธะตะน ัะฒะพั ััะดัะฑั
rus_verbs:ัะพะฒะฟะฐะดะฐัั{}, // ัะพะฒะฟะฐะดะฐัั ั ะฟัะตะดัะบะฐะทะฐะฝะธะตะผ
rus_verbs:ัะฐะฝัะตะฒะฐัั{}, // ัะฐะฝัะตะฒะฐัั ั ะดะตะฒััะบะฐะผะธ
rus_verbs:ะฟะพะดะตะปะธัััั{}, // ะฟะพะดะตะปะธัััั ั ะฒัะถะธะฒัะธะผะธ
rus_verbs:ะพััะฐะฒะฐัััั{}, // ั ะฝะต ั
ะพัะตะป ะพััะฐะฒะฐัััั ั ะฝะธะผ ะฒ ะพะดะฝะพะน ะบะพะผะฝะฐัะต.
rus_verbs:ะฑะตัะตะดะพะฒะฐัั{}, // ะฟัะตะฟะพะดะฐะฒะฐัะตะปั, ะฑะตัะตะดัััะธะน ัะพ ัััะดะตะฝัะฐะผะธ
rus_verbs:ะฑะพัะพัััั{}, // ัะตะปะพะฒะตะบ, ะฑะพัััะธะนัั ัะพ ัะผะตััะตะปัะฝะพะน ะฑะพะปะตะทะฝัั
rus_verbs:ัะตะฟัะฐัััั{}, // ะดะตะฒะพัะบะฐ, ัะตะฟัััะฐััั ั ะฟะพะดััะณะพะน
rus_verbs:ัะฟะปะตัะฝะธัะฐัั{}, // ะถะตะฝัะธะฝะฐ, ัะฟะปะตัะฝะธัะฐะฒัะฐั ั ัะพะฒะฐัะบะฐะผะธ
rus_verbs:ะฟะพะณะพะฒะพัะธัั{}, // ะฟะพะณะพะฒะพัะธัั ั ะฒะธะฝะพะฒะฝะธะบะฐะผะธ
rus_verbs:ัะบะฐะทะฐัั{}, // ัะบะฐะทะฐัั ั ัััะดะพะผ
rus_verbs:ะฟัะพะธะทะฝะตััะธ{}, // ะฟัะพะธะทะฝะตััะธ ั ัััะดะพะผ
rus_verbs:ะณะพะฒะพัะธัั{}, // ะณะพะฒะพัะธัั ั ะฐะบัะตะฝัะพะผ
rus_verbs:ะฟัะพะธะทะฝะพัะธัั{}, // ะฟัะพะธะทะฝะพัะธัั ั ัััะดะพะผ
rus_verbs:ะฒัััะตัะฐัััั{}, // ะบัะพ ั ะะฝัะพะฝะธะพ ะฒัััะตัะฐะปัั?
rus_verbs:ะฟะพัะธะดะตัั{}, // ะฟะพัะธะดะตัั ั ะดััะทััะผะธ
rus_verbs:ัะฐัะบะฒะธัะฐัััั{}, // ัะฐัะบะฒะธัะฐัััั ั ะพะฑะธะดัะธะบะพะผ
rus_verbs:ะฟะพะบะฒะธัะฐัััั{}, // ะฟะพะบะฒะธัะฐัััั ั ะพะฑะธะดัะธะบะพะผ
rus_verbs:ััะณะฐัััั{}, // ััะณะฐัััั ั ะถะตะฝะพะน
rus_verbs:ะฟะพัะบะฐะฝะดะฐะปะธัั{}, // ะฟะพัะบะฐะฝะดะฐะปะธัั ั ะถะตะฝะพะน
rus_verbs:ะฟะพัะฐะฝัะตะฒะฐัั{}, // ะฟะพัะฐะฝัะตะฒะฐัั ั ะฟะพะดััะณะพะน
rus_verbs:ัะบะฐะฝะดะฐะปะธัั{}, // ัะบะฐะฝะดะฐะปะธัั ั ัะพัะตะดัะผะธ
rus_verbs:ัะฐะทััะณะฐัััั{}, // ัะฐะทััะณะฐัััั ั ะดััะณะพะผ
rus_verbs:ะฑะพะปัะฐัั{}, // ะฑะพะปัะฐัั ั ะฟะพะดััะณะฐะผะธ
rus_verbs:ะฟะพััะตะฟะฐัััั{}, // ะฟะพััะตะฟะฐัััั ั ัะพัะตะดะบะพะน
rus_verbs:ะฒะพะนัะธ{}, // ะฒะพะนัะธ ั ัะตะณะธัััะฐัะธะตะน
rus_verbs:ะฒั
ะพะดะธัั{}, // ะฒั
ะพะดะธัั ั ัะตะณะธัััะฐัะธะตะน
rus_verbs:ะฒะพะทะฒัะฐัะฐัััั{}, // ะฒะพะทะฒัะฐัะฐัััั ั ััะธัะผัะพะผ
rus_verbs:ะพะฟะพะทะดะฐัั{}, // ะะฝ ะพะฟะพะทะดะฐะป ั ะฟะพะดะฐัะตะน ัะพัะธะฝะตะฝะธั.
rus_verbs:ะผะพะปัะฐัั{}, // ะะฝ ะผะพะปัะฐะป ั ะปะตะดัะฝัะผ ัะฟะพะบะพะนััะฒะธะตะผ.
rus_verbs:ััะฐะถะฐัััั{}, // ะะฝ ะณะตัะพะธัะตัะบะธ ััะฐะถะฐะปัั ั ะฒัะฐะณะฐะผะธ.
rus_verbs:ะฒัั
ะพะดะธัั{}, // ะะฝ ะฒัะตะณะดะฐ ะฒัั
ะพะดะธั ั ะทะพะฝัะธะบะพะผ.
rus_verbs:ัะปะธัะฐัั{}, // ัะปะธัะฐัั ะฟะตัะตะฒะพะด ั ะพัะธะณะธะฝะฐะปะพะผ
rus_verbs:ะฝะฐัะฐัั{}, // ั ะฝะฐัะฐะป ั ัะพะฒะฐัะธัะตะผ ัะฟะพั ะพ ัะตะปะธะณะธะธ
rus_verbs:ัะพะณะปะฐัะพะฒะฐัั{}, // ะะฐัะฐ ัะพะณะปะฐัะพะฒะฐะปะฐ ั ะะตัะตะน ะดะฐะปัะฝะตะนัะธะต ะฟะพะตะทะดะบะธ
rus_verbs:ะฟัะธั
ะพะดะธัั{}, // ะัะธั
ะพะดะธัะต ั ะฝะตั.
rus_verbs:ะถะธัั{}, // ะบัะพ ั ัะพะฑะพะน ะถะธะป?
rus_verbs:ัะฐัั
ะพะดะธัััั{}, // ะะฐัะฐ ัะฐัั
ะพะดะธััั ั ะะตัะตะน
rus_verbs:ััะตะฟะปััั{}, // ััะตะฟะปััั ะบะฐัะฐะฑะธะฝ ั ะพะฑะฒัะทะบะพะน
rus_verbs:ัะพัะณะพะฒะฐัั{}, // ะผั ัะพัะณัะตะผ ั ะฝะธะผะธ ะฝะตัััั
rus_verbs:ัะตะดะธะฝััััั{}, // ัะตะดะธะฝััััั ั ะฟะพะดััะณะพะน ะฒ ะดะพะผะต
rus_verbs:ัะปะฐะดะธัั{}, // ัะปะฐะดะธัั ะบะพะฝัะปะธะบั ั ัะพัะตะดัะผะธ
rus_verbs:ะธะดัะธ{}, // ะฏ ัะตะป ััะดะฐ ั ััะถัะปัะผ ัะตัะดัะตะผ.
rus_verbs:ัะฐะทะดะตะปััั{}, // ะฏ ัะฐะทะดะตะปัั ั ะฒะฐะผะธ ะณะพัะต ะธ ัะฐะดะพััั.
rus_verbs:ะพะฑัะฐัะธัััั{}, // ะฏ ะพะฑัะฐัะธะปัั ะบ ะฝะตะผั ั ะฟัะพััะฑะพะน ะพ ะฟะพะผะพัะธ.
rus_verbs:ะทะฐั
ะฒะฐัะธัั{}, // ะฏ ะฝะต ะทะฐั
ะฒะฐัะธะป ั ัะพะฑะพะน ะดะตะฝะตะณ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะทะฝะฐะบะพะผัะน{}, // ะฏ ะทะฝะฐะบะพะผ ั ะฝะธะผะธ ะพะฑะพะธะผะธ.
rus_verbs:ะฒะตััะธ{}, // ะฏ ะฒะตะดั ั ะฝะตะน ะฟะตัะตะฟะธัะบั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะพะฟััะถะตะฝะฝัะน{}, // ะญัะพ ัะพะฟััะถะตะฝะพ ั ะฑะพะปััะธะผะธ ัััะดะฝะพัััะผะธ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฒัะทะฐะฝะฝัะน{ะฟัะธัะฐััะธะต}, // ะญัะพ ะดะตะปะพ ัะฒัะทะฐะฝะพ ั ัะธัะบะพะผ.
rus_verbs:ะฟะพะตั
ะฐัั{}, // ะฅะพัะธัะต ะฟะพะตั
ะฐัั ัะพ ะผะฝะพะน ะฒ ัะตะฐัั?
rus_verbs:ะฟัะพัะฝััััั{}, // ะฃััะพะผ ั ะฟัะพัะฝัะปัั ั ััะฝะพะน ะณะพะปะพะฒะพะน.
rus_verbs:ะปะตัะตัั{}, // ะกะฐะผะพะปัั ะปะตัะตะป ัะพ ัะบะพัะพัััั ะทะฒัะบะฐ.
rus_verbs:ะธะณัะฐัั{}, // ะก ะพะณะฝัะผ ะธะณัะฐัั ะพะฟะฐัะฝะพ!
rus_verbs:ะฟะพะดะตะปะฐัั{}, // ะก ะฝะธะผ ะฝะธัะตะณะพ ะฝะต ะฟะพะดะตะปะฐะตัั.
rus_verbs:ััััััะธัั{}, // ะก ะฝะตะน ัััััะปะพัั ะฝะตััะฐัััะต.
rus_verbs:ัะผะพััะตัััั{}, // ะัะตัะฐ ัะผะพััะธััั ั ัะดะพะฒะพะปัััะฒะธะตะผ.
rus_verbs:ัะผะพััะตัั{}, // ะะฝะฐ ัะผะพััะตะปะฐ ะฝะฐ ะผะตะฝั ั ัะฒะฝัะผ ะฝะตัะดะพะฒะพะปัััะฒะธะตะผ.
rus_verbs:ัะฐะทะพะนัะธัั{}, // ะะฝะฐ ัะฐะทะพัะปะฐัั ั ะผัะถะตะผ.
rus_verbs:ะฟัะธััะฐัั{}, // ะะฝะฐ ะฟัะธััะฐะปะฐ ะบะพ ะผะฝะต ั ัะฐััะฟัะพัะฐะผะธ.
rus_verbs:ะฟะพัะผะพััะตัั{}, // ะะฝะฐ ะฟะพัะผะพััะตะปะฐ ะฝะฐ ะผะตะฝั ั ัะดะธะฒะปะตะฝะธะตะผ.
rus_verbs:ะฟะพัััะฟะธัั{}, // ะะฝะฐ ะฟะปะพั
ะพ ะฟะพัััะฟะธะปะฐ ั ะฝะธะผ.
rus_verbs:ะฒัะนัะธ{}, // ะะฝะฐ ะฒััะปะฐ ั ัััะฐะปัะผ ะธ ะฝะตะดะพะฒะพะปัะฝัะผ ะฒะธะดะพะผ.
rus_verbs:ะฒะทััั{}, // ะะพะทัะผะธัะต ั ัะพะฑะพะน ัะพะปัะบะพ ัะฐะผะพะต ะฝะตะพะฑั
ะพะดะธะผะพะต.
rus_verbs:ะฝะฐะฟะปะฐะบะฐัััั{}, // ะะฐะฟะปะฐัะตััั ะพะฝะฐ ั ะฝะธะผ.
rus_verbs:ะปะตะถะฐัั{}, // ะะฝ ะปะตะถะธั ั ะฒะพัะฟะฐะปะตะฝะธะตะผ ะปัะณะบะธั
.
rus_verbs:ะดััะฐัั{}, // ะดััะฐัะธะน ั ัััะดะพะผ
rus_verbs:ะฑัะฐัั{}, // ะฑัะฐัั ั ัะพะฑะพะน
rus_verbs:ะผัะฐัััั{}, // ะะฒัะพะผะพะฑะธะปั ะผัะธััั ั ะฝะตะพะฑััะฐะนะฝะพะน ะฑััััะพัะพะน.
rus_verbs:ัะฟะฐััั{}, // ะะฐะทะฐ ัะฟะฐะปะฐ ัะพ ะทะฒะพะฝะพะผ.
rus_verbs:ะฒะตัะฝััััั{}, // ะผั ะฒะตัะฝัะปะธัั ะฒัะตัะฐ ะดะพะผะพะน ั ะฟะพะปะฝัะผ ะปัะบะพัะบะพะผ
rus_verbs:ัะธะดะตัั{}, // ะะฝะฐ ัะธะดะธั ะดะพะผะฐ ั ัะตะฑะตะฝะบะพะผ
rus_verbs:ะฒัััะตัะธัััั{}, // ะฒัััะตัะฐัััั ั ะบะตะผ-ะปะธะฑะพ
ะะ_ะะะค(ะฟัะธะดัะธ), ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟัะธัะตะดัะธะน{}, // ะฟัะธัะตะดัะธะน ั ะดััะณะพะผ
ะะ_ะะะค(ะฟะพััะธัะฐัั), ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะพััะธัะฐะฝะฝัะน{}, ะดะตะตะฟัะธัะฐััะธะต:ะฟะพััะธัะฐะฒ{},
rus_verbs:ะผััั{}
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะก_ะขะฒะพั ะฟัะตะดะปะพะณ:ั{} @regex("[a-z]+[0-9]*") }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะก_ะขะฒะพั ะฟัะตะดะปะพะณ:ั{} *:*{ะฟะฐะดะตะถ:ัะฒะพั} }
then return true
}
#endregion ะขะะะ ะะขะะะฌะะซะ
#region ะ ะะะะขะะะฌะะซะ
wordentry_set ะะป_ะก_ะ ะพะด=
{
rus_verbs:ะฃะฅะะะะขะฌ{}, // ะะพ ั ะฑะฐะทั ะฝะต ัั
ะพะดะธัั.
rus_verbs:ะ ะะะะฃะขะฌ{}, // ะะพะดะธัะตะปั ะฟัะพัััะฐะป ะฟัะพะบะปััะธะต ะธ ัะฒะฐะฝัะป ะผะฐัะธะฝั ั ะผะตััะฐ. (ะ ะะะะฃะขะฌ)
rus_verbs:ะะฅะะะขะะขะฌ{}, // ะพะณะพะฝั ะพั
ะฒะฐัะธะป ะตะณะพ ัะพ ะฒัะตั
ััะพัะพะฝ (ะะฅะะะขะะขะฌ)
rus_verbs:ะะะะะขะะขะฌ{}, // ะะฝ ะฟะพะฝะธะผะฐะป, ััะพ ัะฒะตั ะธะท ัะฐะนะฝะธะบะฐ ะฝะตะฒะพะทะผะพะถะฝะพ ะทะฐะผะตัะธัั ั ะฟะฐะปัะฑั (ะะะะะขะะขะฌ/ะ ะะะะะฏะะะขะฌ)
rus_verbs:ะ ะะะะะฏะะะขะฌ{}, //
rus_verbs:ะกะะะะะะ ะะะะขะฌ{}, // ะัะธัั ัะฐะทะผะตัะพะผ ั ะพัะปะธัั, ะฒะตัะพััะฝะพ, ะฝะต ะผะพะณะปะธ ะฑั ะฟะพะดะฝััััั ะฒ ะฒะพะทะดัั
, ะฝะต ัะฟะปะฐะฝะธัะพะฒะฐะฒ ั ะฒััะพะบะพะณะพ ััะตัะฐ. (ะกะะะะะะ ะะะะขะฌ)
rus_verbs:ะฃะะะ ะะขะฌ{}, // ะะฝ ัะผัะตั ั ะณะพะปะพะดั. (ะฃะะะ ะะขะฌ)
rus_verbs:ะะกะะฃะะะฃะขะฌ{}, // ะะฑะฐ ัะฟะฐะปะธ ั ะปัะทะณะพะผ, ะฒัะฟัะณะฝัะฒัะธะผ ะฟัะธั ั ะฑะปะธะถะฐะนัะธั
ะดะตัะตะฒัะตะฒ (ะะกะะฃะะะฃะขะฌ)
rus_verbs:ะ ะะะะขะฌ{}, // ะัะตะผั ะพั ะฒัะตะผะตะฝะธ ะบะฐะบะพะน-ัะพ ััะตั ัะตะฒะตะป ั ะฑะตัะตะณะฐ ะธะปะธ ัะฐะผะพะน ัะตะบะธ. (ะ ะะะะขะฌ/ะะะ ะะะะขะฌ/ะะ ะะ ะะะะขะฌ/ะะะะ ะะขะฌ/ะะ ะะะ ะะขะฌ/ะะ ะะขะฌ/ะะ ะะะ ะะงะะขะฌ/ะะะะ ะะงะะขะฌ/ะะะะะขะฌ/ะะะะะะะขะฌ)
rus_verbs:ะะะ ะะะะขะฌ{}, //
rus_verbs:ะะ ะะ ะะะะขะฌ{}, //
rus_verbs:ะะะะ ะะขะฌ{}, //
rus_verbs:ะะ ะะะ ะะขะฌ{}, //
rus_verbs:ะะ ะะขะฌ{}, //
rus_verbs:ะะะะ ะะงะะขะฌ{},
rus_verbs:ะะะะะขะฌ{}, //
rus_verbs:ะะะะะะะขะฌ{}, //
rus_verbs:ะกะขะะฉะะขะฌ{}, // ะฏ ะฒะธะดะตะปะฐ ะบะฐะบ ะพะฝะธ ััะฐัะธะปะธ ะตะณะพ ั ะฒะฐะปัะฝะฐ ะธ ัะฒะตะปะธ ั ัะพะฑะพะน. (ะกะขะะฉะะขะฌ/ะกะขะะกะะะะะขะฌ)
rus_verbs:ะกะขะะกะะะะะขะฌ{}, //
rus_verbs:ะะ ะะะซะขะฌ{}, // ะัะธะทัะฐะบ ัััะฑะฝะพะณะพ ะทะพะฒะฐ ะฟัะพะฒัะป ั ะดััะณะพะน ััะพัะพะฝั ะดะฒะตัะตะน. (ะะ ะะะซะขะฌ, ะะะะซะขะฌ, ะะซะขะฌ)
rus_verbs:ะะะะซะขะฌ{}, //
rus_verbs:ะะซะขะฌ{}, //
rus_verbs:ะกะะะขะะขะฌ{}, // ะะพะปัะดะตะฝะฝะพะต ะผะฐะนัะบะพะต ัะพะปะฝัะต ััะบะพ ัะฒะตัะธะปะพ ั ะณะพะปัะฑัั
ะฝะตะฑะตั ะัะธะทะพะฝั. (ะกะะะขะะขะฌ)
rus_verbs:ะะขะกะะะงะะะะขะฌ{}, // ะกะพะปะฝัะต ะพััะฒะตัะธะฒะฐะปะพ ั ะฑะตะปัั
ะปะพัะฐะดะตะน, ะฑะตะปัั
ัะธัะพะฒ ะธ ะฑะตะปัั
ะฟะตััะตะฒ ะธ ะธัะบัะธะปะพัั ะฝะฐ ะฝะฐะบะพะฝะตัะฝะธะบะฐั
ะฟะธะบ. (ะะขะกะะะงะะะะขะฌ ะก, ะะกะะ ะะขะฌะกะฏ ะะ)
rus_verbs:ะฟะตัะตะณะฝะฐัั{}, // ะกะบะพั ะฝัะถะฝะพ ะฟะตัะตะณะฝะฐัั ั ััะพะณะพ ะฟะฐััะฑะธัะฐ ะฝะฐ ะดััะณะพะต
rus_verbs:ัะพะฑะธัะฐัั{}, // ะผะฐะปััะธะบะธ ะฝะฐัะฐะปะธ ัะพะฑะธัะฐัั ัะพ ััะพะปะพะฒ ะฟะพััะดั
rus_verbs:ัะฐะทะณะปัะดัะฒะฐัั{}, // ัั ะตะต ัะพ ะฒัะตั
ััะพัะพะฝ ัะฐะทะณะปัะดัะฒะฐะป
rus_verbs:ะกะะะะะขะฌ{}, // ะผะตะฝั ะฟะปะพัะฝะพ ัะถะธะผะฐะปะธ ัะพ ะฒัะตั
ััะพัะพะฝ (ะกะะะะะขะฌ)
rus_verbs:ะกะะะ ะะขะฌะกะฏ{}, // ัะพ ะฒัะตะณะพ ัะฒะตัะฐ ัะพะฑัะฐะปะธัั! (ะกะะะ ะะขะฌะกะฏ)
rus_verbs:ะะะะะะฏะขะฌ{}, // ะะธะฝะพ ะฒ ะฟะฐะบะตัะฐั
ะธะทะณะพะฝััั ั ััะฝะบะฐ (ะะะะะะฏะขะฌ)
rus_verbs:ะะะฎะะะขะฌะกะฏ{}, // ะฒะปัะฑะธะปัั ะฒ ะฝะตะต ั ะฟะตัะฒะพะณะพ ะฒะทะณะปัะดะฐ (ะะะฎะะะขะฌะกะฏ)
rus_verbs:ะ ะะะะะะะขะฌะกะฏ{}, // ัะตะฟะตัั ะบัะธะบ ัะฐะทะดะฐะฒะฐะปัั ัะพ ะฒัะตั
ััะพัะพะฝ (ะ ะะะะะะะขะฌะกะฏ)
rus_verbs:ะะะกะะะขะ ะะขะฌ{}, // ะะพัะผะพััะธัะต ะฝะฐ ััะพ ั ะผะพะตะน ัะพัะบะธ ะทัะตะฝะธั (ะะะกะะะขะ ะะขะฌ ะก ัะพะด)
rus_verbs:ะกะฅะะะะขะฌ{}, // ะฟัะธะฝะธะผะฐัั ััะฐััะธะต ะฒะพ ะฒัะตั
ััะธั
ัะพะฑััะธัั
- ะทะฝะฐัะธั ะฟัะพะดะพะปะถะฐัั ัั
ะพะดะธัั ั ัะผะฐ (ะกะฅะะะะขะฌ ะก ัะพะด)
rus_verbs:ะ ะฃะฅะะฃะขะฌ{}, // ะ ะะฐัะบะธัะธะธ ะผะธะบัะพะฐะฒัะพะฑัั ััั
ะฝัะป ั ะผะพััะฐ (ะ ะฃะฅะะฃะขะฌ ะก)
rus_verbs:ะฃะะะะะขะฌ{}, // ัะตะบะพะผะตะฝะดะพะฒะฐัั ัะฒะพะปะธัั ะธั
ั ัะฐะฑะพัั (ะฃะะะะะขะฌ ะก)
rus_verbs:ะะฃะะะขะฌ{}, // ะตะดะฐ , ะบัะฟะปะตะฝะฝะฐั ั ััะบ (ะะฃะะะขะฌ ะก ัะพะด)
rus_verbs:ะฃะะ ะะขะฌ{}, // ะฟะพะผะพัั ัะฑัะฐัั ัะพ ััะพะปะฐ? (ะฃะะ ะะขะฌ ะก)
rus_verbs:ะขะฏะะฃะขะฌ{}, // ั ะผะพัั ััะฝัะปะพ ะฒะตััะพะผ (ะขะฏะะฃะขะฌ ะก)
rus_verbs:ะะ ะะฅะะะะขะฌ{}, // ะฟัะธั
ะพะดะธั ั ัะฐะฑะพัั ะผัะถ (ะะ ะะฅะะะะขะฌ ะก)
rus_verbs:ะะ ะะะะกะขะฌ{}, // ะธะทะพะฑัะฐะถะตะฝะธะต ะฟัะพะฟะฐะปะพ ั ัะบัะฐะฝะฐ (ะะ ะะะะกะขะฌ ะก)
rus_verbs:ะะะขะฏะะฃะขะฌ{}, // ั ะฑะฐะปะบะพะฝะฐ ะฟะพััะฝัะปะพ ั
ะพะปะพะดะพะผ (ะะะขะฏะะฃะขะฌ ะก ัะพะด)
rus_verbs:ะ ะะะะะขะฌะกะฏ{}, // ั ะฟะฐะปัะฑั ัะฐะทะดะฐะปัั ัะฒะธัั (ะ ะะะะะขะฌะกะฏ ะก ัะพะด)
rus_verbs:ะะะะขะ{}, // ะทะฐัะตะป ั ะดััะณะพะน ััะพัะพะฝั (ะะะะขะ ะก ัะพะด)
rus_verbs:ะะะงะะขะฌ{}, // ะดะฐะฒะฐะน ะฝะฐัะฝะตะผ ั ััะพะณะพ (ะะะงะะขะฌ ะก ัะพะด)
rus_verbs:ะฃะะะกะขะ{}, // ะดะฐะปะฐ ัะฒะตััะธ ั ัะฐะทะฒะฐะปะธะฝ (ะฃะะะกะขะ ะก ัะพะด)
rus_verbs:ะะะฃะกะะะขะฌะกะฏ{}, // ั ะณะพั ะพะฟััะบะฐะปะฐัั ะฝะพัั (ะะะฃะกะะะขะฌะกะฏ ะก)
rus_verbs:ะะกะะะงะะขะฌ{}, // ะขัะธััะฐะฝ ะฒัะบะพัะธะป ั ะผะตััะฐ (ะะกะะะงะะขะฌ ะก ัะพะด)
rus_verbs:ะะ ะะขะฌ{}, // ะฑะตัั ั ะฝะตะณะพ ะฟัะธะผะตั (ะะ ะะขะฌ ะก ัะพะด)
rus_verbs:ะะ ะะะะะะฏะขะฌะกะฏ{}, // ะณะพะปะพะฒะฐ ะฟัะธะฟะพะดะฝัะปะฐัั ั ะฟะปะตัะฐ (ะะ ะะะะะะฏะขะฌะกะฏ ะก ัะพะด)
rus_verbs:ะะะฏะะะขะฌะกะฏ{}, // ะฒัะฐะดะฝะธะบะธ ะฟะพัะฒะธะปะธัั ั ะฒะพััะพะบะฐ (ะะะฏะะะขะฌะกะฏ ะก ัะพะด)
rus_verbs:ะะะะะขะะขะฌ{}, // ั ะผะพัั ะฝะฐะปะตัะตะป ะฒะตัะตั (ะะะะะขะะขะฌ ะก ัะพะด)
rus_verbs:ะะะะะขะฌะกะฏ{}, // ะะฐัะฐะฝ ะฒะทะฒะธะปัั ั ะผะตััะฐ (ะะะะะขะฌะกะฏ ะก ัะพะด)
rus_verbs:ะะะะะะ ะะขะฌ{}, // ะฟะพะดะพะฑัะฐะป ั ะทะตะผะปะธ ะบะพะฟัะต (ะะะะะะ ะะขะฌ ะก)
rus_verbs:ะะะ ะะฃะขะฌะกะฏ{}, // ะะธัะธะปะป ะดะตัะฝัะปัั ั ะผะตััะฐ (ะะะ ะะฃะขะฌะกะฏ ะก ัะพะด)
rus_verbs:ะะะะะ ะะฉะะขะฌะกะฏ{}, // ะพะฝะธ ะฒะพะทะฒัะฐัะฐะปะธัั ั ัะตะบะธ (ะะะะะ ะะฉะะขะฌะกะฏ ะก ัะพะด)
rus_verbs:ะะะซะขะฌ{}, // ะฟะปัะปะธ ะพะฝะธ ั ะทะฐะฟะฐะดะฐ (ะะะซะขะฌ ะก ัะพะด)
rus_verbs:ะะะะขะฌ{}, // ะพะดะฝะพ ะทะฝะฐะปะธ ั ะดัะตะฒะฝะพััะธ (ะะะะขะฌ ะก)
rus_verbs:ะะะะะะะะขะฌะกะฏ{}, // ะฒัะฐะดะฝะธะบ ะฝะฐะบะปะพะฝะธะปัั ั ะปะพัะฐะดะธ (ะะะะะะะะขะฌะกะฏ ะก)
rus_verbs:ะะะงะะขะฌะกะฏ{}, // ะฝะฐัะฐะปะพัั ะฒัะต ัะพ ัะบัะบะธ (ะะะงะะขะฌะกะฏ ะก)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะะะะกะขะะซะ{}, // ะัะปััััะฐ ะตะณะพ ะธะทะฒะตััะฝะฐ ัะพ ะฒัะตะผะตะฝ ะณะปัะฑะพะบะพะน ะดัะตะฒะฝะพััะธ (ะะะะะกะขะะซะ ะก)
rus_verbs:ะกะะะขะฌ{}, // ะะพััะฒ ะฒะตััะฐ ัะฑะธะป ะะฐะฝัะบั ั ะฝะพะณ (ts ะกะะะขะฌ ะก)
rus_verbs:ะกะะะะ ะะขะฌะกะฏ{}, // ะพะฝะธ ัะพะฑะธัะฐัััั ััะดะฐ ัะพ ะฒัะตะน ัะฐะฒะฝะธะฝั. (ะกะะะะ ะะขะฌะกะฏ ะก ัะพะด)
rus_verbs:ัะผััั{}, // ะะพะถะดั ะดะพะปะถะตะฝ ัะผััั ั ะปะธัััะตะฒ ะฒัั ะฟัะปั. (ะกะะซะขะฌ ะก)
rus_verbs:ะฟัะธะฒััะฐัั{}, // ะะฐััะธะฝ ะฟัะธะฒััะฐะป ัะพ ัะฒะพะตะณะพ ัััะปะฐ. (ะฟัะธะฒััะฐัั ั)
rus_verbs:ัะฟะฐััั{}, // ััะถะตััั ัะฟะฐะปะฐ ั ะดััะธ. (ัะฟะฐััั ั)
rus_verbs:ะฒัะณะปัะดะตัั{}, // ัะฐะบ ะพะฝะพ ัะพ ััะพัะพะฝั ะฒัะณะปัะดะตะปะพ. (ะะซะะะฏะะะขะฌ ะก)
rus_verbs:ะฟะพะฒะตัะฝััั{}, // ะบ ะฒะตัะตัั ะพะฝะธ ะฟะพะฒะตัะฝัะปะธ ั ะฝะตะต ะฝะฐะฟัะฐะฒะพ. (ะะะะะ ะะฃะขะฌ ะก)
rus_verbs:ะขะฏะะฃะขะฌะกะฏ{}, // ัะพ ััะพัะพะฝั ัะตะบะธ ะบะพ ะผะฝะต ััะฝัะปะธัั ัะทัะบะธ ััะผะฐะฝะฐ. (ะขะฏะะฃะขะฌะกะฏ ะก)
rus_verbs:ะะะะะะขะฌ{}, // ะะตะฝะตัะฐะป ะฒะพะตะฒะฐะป ั ัะฝัั
ะปะตั. (ะะะะะะขะฌ ะก ัะตะณะพ-ัะพ)
rus_verbs:ะะะะะขะฌ{}, // ะะพะปะพะฒะฐ ะฑะพะปะธั ั ะฟะพั
ะผะตะปัั. (ะะะะะขะฌ ะก)
rus_verbs:ะฟัะธะฑะปะธะถะฐัััั{}, // ัะพ ััะพัะพะฝั ะพัััะพะฒะฐ ะฟัะธะฑะปะธะถะฐะปะฐัั ะปะพะดะบะฐ.
rus_verbs:ะะะขะฏะะฃะขะฌะกะฏ{}, // ัะพ ะฒัะตั
ััะพัะพะฝ ะบ ะฝะตะผั ะฟะพััะฝัะปะธัั ััะบะธ. (ะะะขะฏะะฃะขะฌะกะฏ ะก)
rus_verbs:ะฟะพะนัะธ{}, // ะฝะธะทะบะธะน ะณัะป ะฟะพัะตะป ัะพ ััะพัะพะฝั ะดะพะปะธะฝั. (ะฟะพัะตะป ั)
rus_verbs:ะทะฐัะตะฒะตะปะธัััั{}, // ัะพ ะฒัะตั
ััะพัะพะฝ ะทะฐัะตะฒะตะปะธะปะธัั ะบัััั. (ะทะฐัะตะฒะตะปะธัััั ั)
rus_verbs:ะะงะะขะฌะกะฏ{}, // ัะพ ััะพัะพะฝั ะปะตัะฐ ะผัะฐะปะธัั ะฒัะฐะดะฝะธะบะธ. (ะะงะะขะฌะกะฏ ะก)
rus_verbs:ะะะะะขะฌ{}, // ะปัะดะธ ะฑะตะถะฐะปะธ ัะพ ะฒัะตั
ะฝะพะณ. (ะะะะะขะฌ ะก)
rus_verbs:ะกะะซะจะะขะฌะกะฏ{}, // ััะผ ัะปััะฐะปัั ัะพ ััะพัะพะฝั ะผะพัั. (ะกะะซะจะะขะฌะกะฏ ะก)
rus_verbs:ะะะขะะขะฌ{}, // ัะพ ััะพัะพะฝั ะดะตัะตะฒะฝะธ ะปะตัะตะปะฐ ะฟัะธัะฐ. (ะะะขะะขะฌ ะก)
rus_verbs:ะะะ ะะขะฌ{}, // ะฒัะฐะณะธ ะฟััั ัะพ ะฒัะตั
ััะพัะพะฝ. (ะะะ ะะขะฌ ะก)
rus_verbs:ะะะกะซะะะขะฌะกะฏ{}, // ะฒะพะฟัะพัั ะฟะพััะฟะฐะปะธัั ัะพ ะฒัะตั
ััะพัะพะฝ. (ะะะกะซะะะขะฌะกะฏ ะก)
rus_verbs:ะะะขะ{}, // ัะณัะพะทะฐ ัะปะฐ ัะพ ััะพัะพะฝั ะผะพัั. (ะะะขะ ะก + ัะพะด.ะฟ.)
rus_verbs:ะะะกะะซะจะะขะฌะกะฏ{}, // ัะพ ััะตะฝ ะฟะพัะปััะฐะปะธัั ะบัะธะบะธ ัะถะฐัะฐ. (ะะะกะะซะจะะขะฌะกะฏ ะก)
rus_verbs:ะะะ ะฃะจะะขะฌะกะฏ{}, // ะทะฒัะบะธ ะพะฑัััะธะปะธัั ัะพ ะฒัะตั
ััะพัะพะฝ. (ะะะ ะฃะจะะขะฌะกะฏ ะก)
rus_verbs:ะฃะะะ ะะขะฌ{}, // ะณะพะปะพัะฐ ัะดะฐัะธะปะธ ัะพ ะฒัะตั
ััะพัะพะฝ. (ะฃะะะ ะะขะฌ ะก)
rus_verbs:ะะะะะะะขะฌะกะฏ{}, // ัะพ ััะพัะพะฝั ะดะตัะตะฒะฝะธ ะฟะพะบะฐะทะฐะปะธัั ะทะตะผะปัะฝะต. (ะะะะะะะขะฌะกะฏ ะก)
rus_verbs:ะฟััะณะฐัั{}, // ะฟัะธะดะตััั ะฟััะณะฐัั ัะพ ะฒัะพัะพะณะพ ััะฐะถะฐ. (ะฟััะณะฐัั ั)
rus_verbs:ะกะขะะฏะขะฌ{}, // ัะพ ะฒัะตั
ััะพัะพะฝ ััะพัะป ะปะตั. (ะกะขะะฏะขะฌ ะก)
rus_verbs:ะดะพะฝะพัะธัััั{}, // ััะผ ัะพ ะดะฒะพัะฐ ะดะพะฝะพัะธะปัั ััะดะพะฒะธัะฝัะน. (ะดะพะฝะพัะธัััั ั)
rus_verbs:ะผะตัะฐัั{}, // ะผะตัะฐัั ะฒะพะดั ั ะผัะบะพะน (ะผะตัะฐัั ั)
rus_verbs:ะฒะตััะธัั{}, // ะะตัะตะณะพะฒะพัั ะฒะตะดัััั ั ะฟะพะทะธัะธะธ ัะธะปั. (ะฒะตััะธัั ั)
rus_verbs:ะฒััะฐะฒะฐัั{}, // ะะฝ ะฝะต ะฒััะฐะตั ั ะบัะพะฒะฐัะธ. (ะฒััะฐะฒะฐัั ั)
rus_verbs:ะพะบััะถะฐัั{}, // ะทะตะปะตะฝัะต ััะฟะฐะปััะฐ ะพะบััะถะฐะปะธ ะตะต ัะพ ะฒัะตั
ััะพัะพะฝ. (ะพะบััะถะฐัั ั)
rus_verbs:ะฟัะธัะธัะฐัััั{}, // ะก ะฒะฐั ะฟัะธัะธัะฐะตััั 50 ััะฑะปะตะน.
rus_verbs:ัะพัะบะพะปัะทะฝััั{}, // ะตะณะพ ะพััััะน ะบะปัะฒ ัะพัะบะพะปัะทะฝัะป ั ะตะต ััะบะธ.
rus_verbs:ัะพะบัะฐัะธัั{}, // ะะณะพ ัะพะบัะฐัะธะปะธ ัะพ ัะปัะถะฑั.
rus_verbs:ะฟะพะดะฝััั{}, // ััะบะฐ ะฟะพะดะฝัะปะฐ ั ะฟะพะปะฐ
rus_verbs:ะฟะพะดะฝะธะผะฐัั{},
rus_verbs:ัะฐัะธัั{}, // ัะตะผ ะฒัะตะผะตะฝะตะผ ะดััะณะธะต ะฟัะธัะตะปััั ัะฐัะธะปะธ ัะพ ะฒัะตั
ััะพัะพะฝ ะบะฐะผะฝะธ.
rus_verbs:ะฟะพะปะตัะตัั{}, // ะะฐะปััะธะบ ะฟะพะปะตัะตะป ั ะปะตััะฝะธัั.
rus_verbs:ะปะธัััั{}, // ะฒะพะดะฐ ะปัะตััั ั ะฝะตะฑะฐ
rus_verbs:ะฝะฐัะตัั{}, // ะฝะฐัะตัั ั ัะฐะฟะพะณ
rus_verbs:ัะฟััะณะธะฒะฐัั{}, // ัะฟััะณะธะฒะฐัั ั ะดะฒะธะถััะตะณะพัั ััะฐะผะฒะฐั
rus_verbs:ััะตะทะถะฐัั{}, // ััะตะทะถะฐัั ั ะทะฐัะฒะปะตะฝะฝะพะน ัะตะผั
rus_verbs:ะฟะพะบะฐััะฒะฐัััั{}, // ะฟะพะบะฐััะฒะฐัััั ัะพ ัะผะตั
ั
rus_verbs:ะฟะตัะตัะบะฐะบะธะฒะฐัั{}, // ะฟะตัะตัะบะฐะบะธะฒะฐัั ั ะพะดะฝะพะณะพ ะฟัะธะผะตัะฐ ะฝะฐ ะดััะณะพะน
rus_verbs:ัะดะธัะฐัั{}, // ัะดะธัะฐัั ั ัะตะปะฐ ะบะพะถั
rus_verbs:ัะพัะบะฐะปัะทัะฒะฐัั{}, // ัะพัะบะฐะปัะทัะฒะฐัั ั ะบัััะบะฐ
rus_verbs:ัะผะตัะฐัั{}, // ัะผะตัะฐัั ั ะฟัะธะปะฐะฒะบะพะฒ
rus_verbs:ะบัะฒััะบะฝััััั{}, // ะบัะฒััะบะฝััััั ัะพ ัััะฟะตะฝัะบะธ
rus_verbs:ะฟัะพะบะฐัะบะฐัั{}, // ะฟัะพะบะฐัะบะฐัั ั ะฒะตัะบะธ
rus_verbs:ััััั
ะธะฒะฐัั{}, // ััััั
ะธะฒะฐัั ั ะพะดะตะถะดั
rus_verbs:ัะฒะฐะปะธะฒะฐัััั{}, // ัะฒะฐะปะธะฒะฐัััั ั ะปะตััะฝะธัั
rus_verbs:ัะปะธะทะฝััั{}, // ัะปะธะทะฝััั ั ะปะธัะฐ
rus_verbs:ะดะพััะฐะฒะปััััั{}, // ะดะพััะฐะฒะปััััั ั ัะตัะผั
rus_verbs:ะพะฑัััะฟะฐัั{}, // ะพะฑัััะฟะฐัั ั ะดะฒัั
ััะพัะพะฝ
rus_verbs:ะฟะพะฒัะบะฐะบะธะฒะฐัั{}, // ะฟะพะฒัะบะฐะบะธะฒะฐัั ั ะผะตัั
rus_verbs:ะพะฑะพะทัะตะฒะฐัั{}, // ะพะฑะพะทัะตะฒะฐัั ั ะฒะตััะธะฝั
rus_verbs:ัะปะธะฝััั{}, // ัะปะธะฝััั ั ััะพะบะฐ
rus_verbs:ัะผัะฒะฐัั{}, // ัะผัะฒะฐัั ั ะปะธัะฐ
rus_verbs:ัะฟะธั
ะฝััั{}, // ัะฟะธั
ะฝััั ัะพ ััะพะปะฐ
rus_verbs:ะพะฑะพะทัะตัั{}, // ะพะฑะพะทัะตัั ั ะฒะตััะธะฝั
rus_verbs:ะฝะฐะบัะฟะธัั{}, // ะฝะฐะบัะฟะธัั ั ััะบ
rus_verbs:ัั
ะปัะฝััั{}, // ัั
ะปัะฝััั ั ะฑะตัะตะณะฐ
rus_verbs:ัะฟะธะบะธัะพะฒะฐัั{}, // ัะฟะธะบะธัะพะฒะฐัั ั ะบะธะปะพะผะตััะพะฒะพะน ะฒััะพัั
rus_verbs:ัะฟะพะปะทัะธ{}, // ัะฟะพะปะทัะธ ั ะฟะพะปั ะฑะพั
rus_verbs:ัะฑะธะฒะฐัััั{}, // ัะฑะธะฒะฐัััั ั ะฟััะธ
rus_verbs:ะพัะปััะธัััั{}, // ะพัะปััะธัััั ั ะฟะพััะฐ
rus_verbs:ัะธะณะฐะฝััั{}, // ัะธะณะฐะฝััั ั ะบัััะธ
rus_verbs:ัะผะตััะธัั{}, // ัะผะตััะธัั ั ะฟะพััะฐ
rus_verbs:ัะฟะธัะฐัั{}, // ัะฟะธัะฐัั ั ะพัะธะณะธะฝะฐะปัะฝะพะณะพ ััััะพะนััะฒะฐ
ะธะฝัะธะฝะธัะธะฒ:ัะปะตัะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะปะตัะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ัะปะตัะฐัั ั ััะฐััั
ะดะตะตะฟัะธัะฐััะธะต:ัะปะตัะฐั{},
rus_verbs:ะฝะฐะฟะธะฒะฐัััั{}, // ะฝะฐะฟะธะฒะฐัััั ั ะณะพัั
rus_verbs:ัะฒะตัะธัั{}, // ัะฒะตัะธัั ั ะบัััะธ
rus_verbs:ะทะฐะฟะพะปััะธัั{}, // ะทะฐะฟะพะปััะธัั ัะพ ัะบะปะฐะดะฐ
rus_verbs:ัะฟะฐะดะฐัั{}, // ัะฟะฐะดะฐัั ั ะณะปะฐะท
rus_verbs:ััะฐััะพะฒะฐัั{}, // ััะฐััะพะฒะฐัั ั ะผััะฐ
rus_verbs:ัะฟะตัะตัั{}, // ัะฟะตัะตัั ัะพ ัะบะปะฐะดะฐ
rus_verbs:ัะพะณะฝะฐัั{}, // ัะพะณะฝะฐัั ั ะถะธะฒะพัะฐ
rus_verbs:ัะบะฐััะฒะฐัััั{}, // ัะบะฐััะฒะฐัััั ัะพ ััะพะณะฐ
rus_verbs:ัะฝััััั{}, // ัะฝััััั ั ะฒัะฑะพัะพะฒ
rus_verbs:ัะปะตะทะฐัั{}, // ัะปะตะทะฐัั ัะพ ััะพะปะฐ
rus_verbs:ะดะตะฒะฐัััั{}, // ะดะตะฒะฐัััั ั ะฟะพะดะฒะพะดะฝะพะน ะปะพะดะบะธ
rus_verbs:ะพะณะปะฐัะธัั{}, // ะพะณะปะฐัะธัั ั ััะธะฑัะฝั
rus_verbs:ะบัะฐััั{}, // ะบัะฐััั ัะพ ัะบะปะฐะดะฐ
rus_verbs:ัะฐััะธัะธัั{}, // ัะฐััะธัะธัั ั ัะพััะฐ
rus_verbs:ัะณะฐะดัะฒะฐัั{}, // ัะณะฐะดัะฒะฐัั ั ะฟะพะปััะปะพะฒะฐ
rus_verbs:ะพัะบะพัะฑะธัั{}, // ะพัะบะพัะฑะธัั ัะพ ััะตะฝั
rus_verbs:ัััะฒะฐัั{}, // ัััะฒะฐัั ั ะณะพะปะพะฒั
rus_verbs:ััะธะฑะธัั{}, // ััะธะฑะธัั ั ะบะพะฝั
rus_verbs:ัะฑะธะฒะฐัั{}, // ัะฑะธะฒะฐัั ั ะพะดะตะถะดั
rus_verbs:ัะพะดัะฐัั{}, // ัะพะดัะฐัั ั ะฟะพัะตัะธัะตะปะตะน
rus_verbs:ััะพะปะบะฝััั{}, // ััะพะปะบะฝััั ั ะณะพัั
rus_verbs:ะพัััั
ะฝััั{}, // ะพัััั
ะฝััั ั ะพะดะตะถะดั
rus_verbs:ัะฑัะฐััะฒะฐัั{}, // ัะฑัะฐััะฒะฐัั ั ะฑะพััะฐ
rus_verbs:ัะฐััััะตะปะธะฒะฐัั{}, // ัะฐััััะตะปะธะฒะฐัั ั ะฑะพััะฐ ะฒะตััะพะปะตัะฐ
rus_verbs:ะฟัะธะดัะธ{}, // ะผะฐัั ัะบะพัะพ ะฟัะธะดะตั ั ัะฐะฑะพัั
rus_verbs:ััะตั
ะฐัั{}, // ะะธัะฐ ััะตั
ะฐะป ั ะณะพัะบะธ
rus_verbs:ัะฒะธัะฐัั{}, // ัะฒะธัะฐัั ั ะฒะตัะพะบ
rus_verbs:ัััะฝััั{}, // ัััะฝััั ั ะบัะพะฒะฐัะธ
rus_verbs:ัะบะธะฝััั{}, // ัะบะธะฝััั ัะฝะตะณ ั ะฟะปะตัะฐ
rus_verbs:ะทะฐะณัะตะผะตัั{}, // ะทะฐะณัะตะผะตัั ัะพ ัััะปะฐ
rus_verbs:ััะฟะฐัััั{}, // ััะฟะฐัััั ั ะฝะตะฑะฐ
rus_verbs:ััััั
ะฝััั{}, // ััััั
ะฝััั ั ะณะพะปะพะฒั
rus_verbs:ัะฟะพะปะทัะธ{}, // ัะฟะพะปะทัะธ ัะพ ัััะปะฐ
rus_verbs:ััะตัะตัั{}, // ััะตัะตัั ั ัะบัะฐะฝะฐ
rus_verbs:ะฟัะพะณะฝะฐัั{}, // ะฟัะพะณะฝะฐัั ั ัะตัะผั
rus_verbs:ัะผะฐั
ะฝััั{}, // ัะผะฐั
ะฝััั ัะพ ััะพะปะฐ
rus_verbs:ัะฟััะบะฐัั{}, // ัะฟััะบะฐัั ั ะฟะพะฒะพะดะบะฐ
rus_verbs:ะดะตัััั{}, // ะดะตัััั ั ะฟะพะดะฒะพะดะฝะพะน ะปะพะดะบะธ
rus_verbs:ัะดะตัะฝััั{}, // ัะดะตัะฝััั ั ัะตะฑั
rus_verbs:ัะดะฒะธะฝััััั{}, // ัะดะฒะธะฝััััั ั ะผะตััะฐ
rus_verbs:ัะปะตัะตัั{}, // ัะปะตัะตัั ั ะบะฐัััะตะบ
rus_verbs:ะพะฑัััะฟะธัั{}, // ะพะฑัััะฟะธัั ัะพ ะฒัะตั
ััะพัะพะฝ
rus_verbs:ัะฝะตััะธ{}, // ัะฝะตััะธ ั ะฟะปะตั
ะธะฝัะธะฝะธัะธะฒ:ัะฑะตะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฑะตะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ัะฑะตะณะฐัั ั ััะพะบะพะฒ
ะดะตะตะฟัะธัะฐััะธะต:ัะฑะตะณะฐั{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฑะตะณะฐััะธะน{},
// ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฑะตะณะฐะฒัะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
rus_verbs:ะทะฐะฟะธัั{}, // ะทะฐะฟะธัั ั ะณะพัั
rus_verbs:ััะฑะฐะฝััั{}, // ััะฑะฐะฝััั ั ะฟะปะตัะฐ
rus_verbs:ัะตัััั
ะฝััััั{}, // ัะตัััั
ะฝััััั ั ะดะพัะฐะดั
rus_verbs:ัััะฒะฐัััั{}, // ัััะฒะฐัััั ั ัะตะฟะธ
rus_verbs:ัะผััััั{}, // ัะผััััั ั ััะพะบะพะฒ
rus_verbs:ะฟะพั
ะธัะธัั{}, // ะฟะพั
ะธัะธัั ัะพ ัะบะปะฐะดะฐ
rus_verbs:ัะผะตััะธ{}, // ัะผะตััะธ ัะพ ัะฒะพะตะณะพ ะฟััะธ
rus_verbs:ะพัะณััะถะฐัั{}, // ะพัะณััะถะฐัั ัะพ ัะบะปะฐะดะฐ
rus_verbs:ะพัะณััะทะธัั{}, // ะพัะณััะทะธัั ัะพ ัะบะปะฐะดะฐ
rus_verbs:ะฑัะพัะฐัััั{}, // ะะตัะธ ะฑัะพัะฐะปะธัั ะฒ ะฒะพะดั ั ะผะพััะฐ
rus_verbs:ะฑัะพัะธัััั{}, // ัะฐะผะพัะฑะธะนัะฐ ะฑัะพัะธะปัั ั ะผะพััะฐ ะฒ ะฒะพะดั
rus_verbs:ะฒะทะธะผะฐัั{}, // ะะธะปะตัะตั ะฒะทะธะผะฐะตั ะฟะปะฐัั ั ะบะฐะถะดะพะณะพ ะฟะพัะตัะธัะตะปั
rus_verbs:ะฒะทะธะผะฐัััั{}, // ะะปะฐัะฐ ะฒะทะธะผะฐะตััั ั ะปัะฑะพะณะพ ะฟะพัะตัะธัะตะปั
rus_verbs:ะฒะทััะบะฐัั{}, // ะัะธััะฐะฒั ะฒะทััะบะฐะปะธ ะดะพะปะณ ั ะฑะตะดะพะปะฐะณะธ
rus_verbs:ะฒะทััะบะธะฒะฐัั{}, // ะัะธััะฐะฒั ะฒะทััะบะธะฒะฐัั ั ะฑะตะดะพะปะฐะณะธ ะฒัะต ะดะพะปะณะธ
rus_verbs:ะฒะทััะบะธะฒะฐัััั{}, // ะะพะปะณะธ ะฒะทััะบะธะฒะฐัััั ั ะฐะปะธะผะตะฝััะธะบะพะฒ
rus_verbs:ะฒัะฟะฐัั
ะธะฒะฐัั{}, // ะฒัะฟะฐัั
ะธะฒะฐัั ั ัะฒะตัะบะฐ
rus_verbs:ะฒัะฟะพัั
ะฝััั{}, // ะฒัะฟะพัั
ะฝััั ั ะฒะตัะบะธ
rus_verbs:ะฒัะฑัะพัะธัั{}, // ะฒัะฑัะพัะธัั ััะพ-ัะพ ั ะฑะฐะปะบะพะฝะฐ
rus_verbs:ะฒัะฒะพะดะธัั{}, // ะฒัะฒะพะดะธัั ั ะพะดะตะถะดั ะฟััะฝะฐ
rus_verbs:ัะฝััั{}, // ัะฝััั ั ะณะพะปะพะฒั
rus_verbs:ะฝะฐัะธะฝะฐัั{}, // ะฝะฐัะธะฝะฐัั ั ััะบะธะทะฐ
rus_verbs:ะดะฒะธะฝััััั{}, // ะดะฒะธะฝััััั ั ะผะตััะฐ
rus_verbs:ะฝะฐัะธะฝะฐัััั{}, // ะฝะฐัะธะฝะฐัััั ั ะณะฐัะดะตัะพะฑะฐ
rus_verbs:ััะตัั{}, // ััะตัั ั ะบัััะธ
rus_verbs:ัะปะตะทัั{}, // ัะปะตะทัั ั ะบััะธ
rus_verbs:ัะฟัััะธัััั{}, // ัะฟัััะธัััั ั ะบัััะธ
rus_verbs:ัะพะนัะธ{}, // ัะพะนัะธ ั ะฟัะตะดะตััะฐะปะฐ
rus_verbs:ัะฒะตัะฝััั{}, // ัะฒะตัะฝััั ั ะฟััะธ
rus_verbs:ัะพัะฒะฐัั{}, // ัะพัะฒะฐัั ั ัะตะฟะธ
rus_verbs:ัะพัะฒะฐัััั{}, // ัะพัะฒะฐัััั ั ะฟะพะฒะพะดะบะฐ
rus_verbs:ััะพะฝััััั{}, // ััะพะฝััััั ั ะผะตััะฐ
rus_verbs:ัะณะฐะดะฐัั{}, // ัะณะฐะดะฐัั ั ะฟะตัะฒะพะน ะฟะพะฟััะบะธ
rus_verbs:ัะฟัััะธัั{}, // ัะฟัััะธัั ั ะปะตััะฝะธัั
rus_verbs:ัะพัะบะพัะธัั{}, // ัะพัะบะพัะธัั ั ะบัััะบะฐ
rus_verbs:ัะดะฒะธะฝััั{}, // ัะดะฒะธะฝััั ั ะผะตััะฐ
rus_verbs:ะฟะพะดะฝะธะผะฐัััั{}, // ััะผะฐะฝ, ะฟะพะดะฝะธะผะฐััะธะนัั ั ะฑะพะปะพัะฐ
rus_verbs:ะฟะพะดะฝััััั{}, // ััะผะฐะฝ, ะฟะพะดะฝัะฒัะธะนัั ั ะฑะพะปะพัะฐ
rus_verbs:ะฒะฐะปะธัั{}, // ะ ะตะทะบะธะน ะฟะพััะฒะธัััะน ะฒะตัะตั ะฒะฐะปะธั ะฟัะพั
ะพะถะธั
ั ะฝะพะณ.
rus_verbs:ัะฒะฐะปะธัั{}, // ะ ะตะทะบะธะน ะฟะพััะฒะธัััะน ะฒะตัะตั ัะฒะฐะปะธั ัะตะฑั ั ะฝะพะณ.
rus_verbs:ะดะพะฝะตััะธัั{}, // ะก ัะปะธัั ะดะพะฝะตััั ััะผ ะดะพะถะดั.
rus_verbs:ะพะฟะฐััั{}, // ะะฟะฐะฒัะธะต ั ะดะตัะตะฒะฐ ะปะธัััั.
rus_verbs:ะผะฐั
ะฝััั{}, // ะะฝ ะผะฐั
ะฝัะป ั ะฑะตัะตะณะฐ ะฒ ะฒะพะดั.
rus_verbs:ะธััะตะทะฝััั{}, // ะธััะตะทะฝััั ั ัะบัะฐะฝะฐ
rus_verbs:ัะฒะฐะปะธัััั{}, // ัะฒะฐะปะธัััั ัะพ ััะตะฝั
rus_verbs:ัะฟะฐััั{}, // ัะฟะฐััั ั ะดะตัะตะฒะฐ
rus_verbs:ะฒะตัะฝััััั{}, // ะะฝ ะตัั ะฝะต ะฒะตัะฝัะปัั ั ัะฐะฑะพัั.
rus_verbs:ัะดัะฒะฐัั{}, // ัะดัะฒะฐัั ะฟัั
ั ะพะดัะฒะฐะฝัะธะบะพะฒ
rus_verbs:ัะฒะตัะณะฐัั{}, // ัะฒะตัะณะฐัั ัะฐัั ั ััะพะฝะฐ
rus_verbs:ัะฑะธัััั{}, // ัะฑะธัััั ั ะฟััะธ
rus_verbs:ััะธัะฐัั{}, // ััะธัะฐัั ัััะฟะบะพะน ะฝะฐะดะฟะธัั ั ะดะพัะบะธ
rus_verbs:ัะฑะธัะฐัั{}, // ัะฑะธัะฐัั ะผััะพั c ะฟะพะปะฐ
rus_verbs:ัะดะฐะปััั{}, // ัะดะฐะปััั ะธะณัะพะบะฐ ั ะฟะพะปั
rus_verbs:ะพะบััะถะธัั{}, // ะฏะฟะพะฝะธั ะพะบััะถะตะฝะฐ ัะพ ะฒัะตั
ััะพัะพะฝ ะผะพััะผะธ.
rus_verbs:ัะฝะธะผะฐัั{}, // ะฏ ัะฝะธะผะฐั ั ัะตะฑั ะฒััะบัั ะพัะฒะตัััะฒะตะฝะฝะพััั ะทะฐ ะตะณะพ ะฟะพะฒะตะดะตะฝะธะต.
ะณะปะฐะณะพะป:ะฟะธัะฐัััั{ aux stress="ะฟะธั^ะฐัััั" }, // ะกะพะฑััะฒะตะฝะฝัะต ะธะผะตะฝะฐ ะฟะธััััั ั ะฑะพะปััะพะน ะฑัะบะฒั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฟะพะบะพะนะฝัะน{}, // ะก ััะพะน ััะพัะพะฝั ั ัะฟะพะบะพะตะฝ.
rus_verbs:ัะฟัะพัะธัั{}, // ะก ัะตะฑั ะทะฐ ะฒัั ัะฟัะพััั.
rus_verbs:ัะตัั{}, // ะก ะฝะตะณะพ ัะตััั ะฟะพั.
rus_verbs:ะดััั{}, // ะก ะผะพัั ะดัะตั ะฒะตัะตั.
rus_verbs:ะบะฐะฟะฐัั{}, // ะก ะตะณะพ ะปะธัะฐ ะบะฐะฟะฐะปะธ ะบััะฟะฝัะต ะบะฐะฟะปะธ ะฟะพัะฐ.
rus_verbs:ะพะฟัััะธัั{}, // ะะฝะฐ ะพะฟัััะธะปะฐ ัะตะฑัะฝะบะฐ ั ััะบ ะฝะฐ ะฟะพะป.
rus_verbs:ัะฟััะณะฝััั{}, // ะะฝะฐ ะปะตะณะบะพ ัะฟััะณะฝัะปะฐ ั ะบะพะฝั.
rus_verbs:ะฒััะฐัั{}, // ะัะต ะฒััะฐะปะธ ัะพ ัััะปัะตะฒ.
rus_verbs:ัะฑัะพัะธัั{}, // ะะพะนะดั ะฒ ะบะพะผะฝะฐัั, ะพะฝ ัะฑัะพัะธะป ั ัะตะฑั ะฟะฐะปััะพ.
rus_verbs:ะฒะทััั{}, // ะะพะทัะผะธ ะบะฝะธะณั ั ะฟะพะปะบะธ.
rus_verbs:ัะฟััะบะฐัััั{}, // ะั ัะฟััะบะฐะปะธัั ั ะณะพัั.
rus_verbs:ัะนัะธ{}, // ะะฝ ะฝะฐััะป ัะตะฑะต ะทะฐะผะตััะธัะตะปั ะธ ัััะป ัะพ ัะปัะถะฑั.
rus_verbs:ะฟะพัั
ะฐัั{}, // ะะฐะฑะพัะบะฐ ะฟะพัั
ะฐะตั ั ัะฒะตัะบะฐ ะฝะฐ ัะฒะตัะพะบ.
rus_verbs:ะพัะฟัะฐะฒะปััััั{}, // ะะฐั ะฟะพะตะทะด ะพัะฟัะฐะฒะปัะตััั ัะพ ะฒัะพัะพะน ะฟะปะฐััะพัะผั.
rus_verbs:ะดะฒะธะณะฐัััั{}, // ะะฝ ะฝะต ะดะฒะธะณะฐะปัั ั ะผะตััะฐ.
rus_verbs:ะพัั
ะพะดะธัั{}, // ะผะพะน ะฟะพะตะทะด ะพัั
ะพะดะธั ั ะฟะตัะฒะพะณะพ ะฟััะธ
rus_verbs:ะฟะพะฟะฐััั{}, // ะะฐะนะบะป ะฟะพะฟะฐะป ะฒ ะบะพะปััะพ ั ะดะตัััะธะผะตััะพะฒะพะน ะดะธััะฐะฝัะธะธ
rus_verbs:ะฟะฐะดะฐัั{}, // ัะฝะตะณ ะฟะฐะดะฐะตั ั ะฒะตัะฒะตะน
rus_verbs:ัะบัััััั{} // ะะต ะฒะพะดะธัะตะปั, ะฑัะพัะธะฒ ะผะฐัะธะฝั, ัะบััะปัั ั ะผะตััะฐ ะฟัะพะธััะตััะฒะธั.
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะก_ะ ะพะด ะฟัะตะดะปะพะณ:ั{} @regex("[a-z]+[0-9]*") }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะก_ะ ะพะด ะฟัะตะดะปะพะณ:ั{} *:*{ะฟะฐะดะตะถ:ัะพะด} }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะก_ะ ะพะด ะฟัะตะดะปะพะณ:ั{} *:*{ะฟะฐะดะตะถ:ะฟะฐัั} }
then return true
}
#endregion ะ ะะะะขะะะฌะะซะ
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ั{} *:*{ ะฟะฐะดะตะถ:ัะฒะพั } }
then return false,-3
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ั{} *:*{ ะฟะฐะดะตะถ:ัะพะด } }
then return false,-4
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ั{} * }
then return false,-5
}
#endregion ะัะตะดะปะพะณ_ะก
/*
#region ะัะตะดะปะพะณ_ะะะ
// -------------- ะะ ะะะะะ 'ะะะ' -----------------------
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฟะพะด{} @regex("[a-z]+[0-9]*") }
then return true
}
// ะะะ+ะฒะธะฝ.ะฟ. ะฝะต ะผะพะถะตั ะฟัะธัะพะตะดะธะฝััััั ะบ ัััะตััะฒะธัะตะปัะฝัะผ, ะฟะพััะพะผั
// ะพะฝ ะฟัะธัะพะตะดะธะฝัะตััั ะบ ะปัะฑัะผ ะณะปะฐะณะพะปะฐะผ.
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฟะพะด{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return true
}
wordentry_set ะะป_ะะะ_ัะฒะพั=
{
rus_verbs:ะธะทะฒะธะฒะฐัััั{}, // ะธะทะฒะธะฒะฐะปะฐัั ะฟะพะด ะตะณะพ ะดะปะธะฝะฝัะผะธ ััะฐะผะธ
rus_verbs:ะ ะะกะะ ะะกะขะ ะะะฏะขะฌะกะฏ{}, // ะะพะด ะณััััะผ ะบะพะฒัะพะผ ััะฐะฒั ะธ ะฟะปะพัะฝัะผ ัะฟะปะตัะตะฝะธะตะผ ะบะพัะฝะตะน (ะ ะะกะะ ะะกะขะ ะะะฏะขะฌะกะฏ)
rus_verbs:ะะ ะะกะะขะฌ{}, // ััะพะฑั ัั ะตะณะพ ะฟะพะด ะดะตัะตะฒะพะผ ะฑัะพัะธะป? (ะะ ะะกะะขะฌ)
rus_verbs:ะะะขะฌะกะฏ{}, // ะฟะพะด ะผะพะตะน ัะตะบะพะน ัะธะปัะฝะพ ะฑะธะปะพัั ะตะณะพ ัะตัะดัะต (ะะะขะฌะกะฏ)
rus_verbs:ะะะฃะกะขะะขะฌะกะฏ{}, // ะณะปะฐะทะฐ ะตะณะพ ะพะฟัััะธะปะธัั ะฟะพะด ะตะต ะถะตะปััะผ ะฒะทะณะปัะดะพะผ (ะะะฃะกะขะะขะฌะกะฏ)
rus_verbs:ะะะะซะะะขะฌะกะฏ{}, // ะตะณะพ ะณััะดั ััะดะพัะพะถะฝะพ ะฒะทะดัะผะฐะปะฐัั ะฟะพะด ะตะต ััะบะพะน (ะะะะซะะะขะฌะกะฏ)
rus_verbs:ะะ ะะะงะะขะฌะกะฏ{}, // ะะฝะฐ ะฟัะพะผัะฐะปะฐัั ะฟะพะด ะฝะธะผะธ ะธ ะธััะตะทะปะฐ ะทะฐ ะธะทะณะธะฑะพะผ ะณะพัั. (ะะ ะะะงะะขะฌะกะฏ)
rus_verbs:ะฒัะฟะปััั{}, // ะะฐะบะพะฝะตั ะพะฝ ะฒัะฟะปัะป ะฟะพะด ะฝะฐะฒะธัะฐะฒัะตะน ะบะพัะผะพะน, ัะฐะบ ะธ ะฝะต ะพัััะบะฐะฒ ัะพะณะพ, ััะพ ั
ะพัะตะป. (ะฒัะฟะปััั)
rus_verbs:ะะะะงะะขะฌะกะฏ{}, // ะะฝ ะฟะพััะธ ะฒะตััะธะบะฐะปัะฝะพ ัั
ะพะดะธั ะฒ ัะตะบั ะธ ะบะพะฝัะฐะตััั ะณะปัะฑะพะบะพ ะฟะพะด ะฒะพะดะพะน. (ะะะะงะะขะฌะกะฏ)
rus_verbs:ะะะะะขะ{}, // ะขะฐะผ ะพะฝะธ ะฟะพะปะทะปะธ ะฟะพะด ัะฟััะฐะฝะฝัะผ ัะตัะฝะพะฒะฝะธะบะพะผ ะธ ัะบะฒะพะทั ะฟะตัะตะฟะปะตัะฐะฒัะธะตัั ะบัััั (ะะะะะขะ)
rus_verbs:ะะ ะะฅะะะะขะฌ{}, // ะะพะปัั ะฟัะพั
ะพะดะธะป ะฟะพะด ะณะธะณะฐะฝััะบะธะผะธ ะฒะตัะฒัะผะธ ะดะตัะตะฒัะตะฒ ะธ ะผั
ะพะฒ, ัะฒะธัะฐะฒัะธั
ั ะฒะตัะฒะตะน ะทะตะปะตะฝัะผะธ ะฒะพะดะพะฟะฐะดะฐะผะธ. (ะะ ะะฅะะะะขะฌ, ะะ ะะะะะะขะ, ะะ ะะะะะะะขะฌ)
rus_verbs:ะะ ะะะะะะขะ{}, //
rus_verbs:ะะ ะะะะะะะขะฌ{}, //
rus_verbs:ะะะะขะฌ{}, // ะญัะธ ะฟัะตะดะฟะพะปะพะถะตะฝะธั ะฝะต ะธะผะตัั ะฟะพะด ัะพะฑะพะน ะฝะธะบะฐะบะพะน ะฟะพัะฒั (ะะะะขะฌ)
rus_verbs:ะะะกะะขะฌ{}, // ะพะฝะฐ ะฝะพัะธั ะฟะพะด ัะตัะดัะตะผ ัะตะฑะตะฝะบะฐ (ะะะกะะขะฌ)
rus_verbs:ะะะกะขะฌ{}, // ะ ะธะผ ะฟะฐะป ะฟะพะด ะฝะฐัะธัะบะพะผ ะฒะฐัะฒะฐัะพะฒ (ะะะกะขะฌ)
rus_verbs:ะฃะขะะะฃะขะฌ{}, // ะััััะฟะฐะฒัะธะต ััะฐััะตัะบะธะต ะฒะตะฝั ัะฝะพะฒะฐ ััะพะฝัะปะธ ะฟะพะด ะณะปะฐะดะบะพะน ัะฒะตัะดะพะน ะฟะปะพััั. (ะฃะขะะะฃะขะฌ)
rus_verbs:ะะะะฏะขะฌะกะฏ{}, // ะะพะด ะตะณะพ ะบัะธะฒัะผะธ ัะตััะผะธ ะฒะตัะฒัะผะธ ะธ ะฟะตััััะผะธ ะบะพัะธัะฝะตะฒะพ-ะทะตะปะตะฝัะผะธ ะปะธััััะผะธ ะฒะฐะปัะปะธัั ะฟััััะต ะพัะตั
ะพะฒัะต ัะบะพัะปัะฟะบะธ ะธ ัะตัะดัะตะฒะธะฝั ะฟะปะพะดะพะฒ. (ะะะะฏะขะฌะกะฏ)
rus_verbs:ะฒะทะดัะพะณะฝััั{}, // ะพะฝะฐ ะฒะทะดัะพะณะฝัะปะฐ ะฟะพะด ะตะณะพ ะฒะทะณะปัะดะพะผ
rus_verbs:ะธะผะตัััั{}, // ั ะบะฐะถะดะพะณะพ ะฟะพะด ััะบะพะน ะธะผะตะปัั ะฐัะฑะฐะปะตั
rus_verbs:ะะะะขะฌ{}, // ะกะฐัะบะฐ ัะถะต ะถะดะฐะป ะฟะพะด ะดะพะถะดะตะผ (ะะะะขะฌ)
rus_verbs:ะะะงะะะะขะฌ{}, // ะผะฝะต ะฟัะธั
ะพะดะธะปะพัั ะฝะพัะตะฒะฐัั ะฟะพะด ะพัะบััััะผ ะฝะตะฑะพะผ (ะะะงะะะะขะฌ)
rus_verbs:ะฃะะะะขะฌ{}, // ะฒั ะดะพะปะถะฝั ัะทะฝะฐัั ะผะตะฝั ะฟะพะด ััะธะผ ะธะผะตะฝะตะผ (ะฃะะะะขะฌ)
rus_verbs:ะะะะะ ะะะะะขะฌะกะฏ{}, // ะผะฝะต ะฝะตะปัะทั ะทะฐะดะตัะถะธะฒะฐัััั ะฟะพะด ะทะตะผะปะตะน! (ะะะะะ ะะะะะขะฌะกะฏ)
rus_verbs:ะะะะะะะฃะขะฌ{}, // ะฟะพะด ะธั
ะบะพะฟััะฐะผะธ ะฟะพะณะธะฑะปะธ ัะตะปัะต ะฐัะผะธะธ! (ะะะะะะะฃะขะฌ)
rus_verbs:ะ ะะะะะะะขะฌะกะฏ{}, // ะฟะพะด ะฝะพะณะฐะผะธ ั ะผะตะฝั ัะฐะทะดะฐะฒะฐะปัั ััั
ะพะน ั
ัััั (ะ ะะะะะะะขะฌะกะฏ)
rus_verbs:ะะ ะฃะะะขะฌะกะฏ{}, // ะฟะพะฒะตัั
ะฝะพััั ะฟะปะฐะฝะตัั ะบััะถะธะปะฐัั ั ะฝะตะณะพ ะฟะพะด ะฝะพะณะฐะผะธ (ะะ ะฃะะะขะฌะกะฏ)
rus_verbs:ะะะกะะขะฌ{}, // ะฟะพะด ะณะปะฐะทะฐะผะธ ั ะฝะตะณะพ ะฒะธัะตะปะธ ััะถะตะปัะต ัะบะปะฐะดะบะธ ะบะพะถะธ (ะะะกะะขะฌ)
rus_verbs:ัะพะดัะพะณะฝััััั{}, // ัะพะดัะพะณะฝัะปัั ะฟะพะด ะฝะพะณะฐะผะธ ะบะฐะผะตะฝะฝัะน ะฟะพะป (ะกะะะ ะะะะฃะขะฌะกะฏ)
rus_verbs:ะกะะะะ ะะขะฌะกะฏ{}, // ัะตะผะฝะพัะฐ ัะถะต ัะพะฑะธัะฐะปะฐัั ะฟะพะด ะดะตัะตะฒััะผะธ (ะกะะะะ ะะขะฌะกะฏ)
rus_verbs:ะฃะะะกะขะฌ{}, // ัะพะปัััะบ ัะฟะฐะป ะฟะพะด ะณัะฐะดะพะผ ัะดะฐัะพะฒ (ะฃะะะกะขะฌ)
rus_verbs:ะะะะะฃะขะฌะกะฏ{}, // ะปะพะดะบะฐ ะดะฒะธะฝัะปะฐัั ะฟะพะด ะฒะพะดะพะน (ะะะะะฃะขะฌะกะฏ)
rus_verbs:ะฆะะ ะะขะฌ{}, // ะฟะพะด ะตะณะพ ะบัััะตะน ัะฐัะธะปะฐ ั
ะพะปะพะดะฝะฐั ะทะธะผะฐ (ะฆะะ ะะขะฌ)
rus_verbs:ะะ ะะะะะะขะฌะกะฏ{}, // ะฟะพะด ะบะพะฟััะฐะผะธ ะตะณะพ ะปะพัะฐะดะธ ะฟัะพะฒะฐะปะธะปัั ะผะพัั (ะะ ะะะะะะขะฌะกะฏ ะะะ ัะฒะพั)
rus_verbs:ะะะะ ะะะะขะฌ{}, // ะทะตะผะปั ะทะฐะดัะพะถะฐะปะฐ ะฟะพะด ะฝะพะณะฐะผะธ (ะะะะ ะะะะขะฌ)
rus_verbs:ะะะฅะะฃะ ะะขะฌะกะฏ{}, // ะณะพััะดะฐัั ะฝะฐั
ะผััะธะปัั ะฟะพะด ะผะฐัะบะพะน (ะะะฅะะฃะ ะะขะฌะกะฏ)
rus_verbs:ะ ะะะะขะะขะฌ{}, // ัะฐะฑะพัะฐัั ะฟะพะด ัะณัะพะทะพะน ะฝะตะปัะทั (ะ ะะะะขะะขะฌ)
rus_verbs:ะจะะะะะฌะะฃะขะฌะกะฏ{}, // ะฟะพะด ะฝะพะณะพะน ัะตะฒะตะปัะฝัะปัั ะบะฐะผะตะฝั (ะจะะะะะฌะะฃะขะฌะกะฏ)
rus_verbs:ะะะะะขะฌ{}, // ะฒะธะดะตะป ัะตะฑั ะฟะพะด ะบะฐะผะฝะตะผ. (ะะะะะขะฌ)
rus_verbs:ะะกะขะะขะฌะกะฏ{}, // ะฒัะพัะพะต ะพััะฐะปะพัั ะฟะพะด ะฒะพะดะพะน (ะะกะขะะขะฌะกะฏ)
rus_verbs:ะะะะะขะฌ{}, // ะฒะพะดะฐ ะบะธะฟะตะปะฐ ะฟะพะด ะบะพะฟััะฐะผะธ (ะะะะะขะฌ)
rus_verbs:ะกะะะะขะฌ{}, // ะผะพะถะตั ัะธะดะธั ะฟะพะด ะดะตัะตะฒะพะผ (ะกะะะะขะฌ)
rus_verbs:ะะะะฌะะะฃะขะฌ{}, // ะฟะพะด ะฝะฐะผะธ ะผะตะปัะบะฝัะปะพ ะผะพัะต (ะะะะฌะะะฃะขะฌ)
rus_verbs:ะะะกะะซะจะะขะฌะกะฏ{}, // ะฟะพะด ะพะบะฝะพะผ ะฟะพัะปััะฐะปัั ััะผ (ะะะกะะซะจะะขะฌะกะฏ)
rus_verbs:ะขะฏะะฃะขะฌะกะฏ{}, // ะฟะพะด ะฝะฐะผะธ ััะฝัะปะธัั ะพะฑะปะฐะบะฐ (ะขะฏะะฃะขะฌะกะฏ)
rus_verbs:ะะ ะะะะขะฌ{}, // ะทะตะผะปั ะดัะพะถะฐะปะฐ ะฟะพะด ะฝะธะผ (ะะ ะะะะขะฌ)
rus_verbs:ะะ ะะะขะะกะฌ{}, // ั
ัะถะต ะฟัะธัะปะพัั ะฟะพะด ะทะตะผะปะตะน (ะะ ะะะขะะกะฌ)
rus_verbs:ะะะ ะะขะฌ{}, // ะปะฐะผะฟะฐ ะณะพัะตะปะฐ ะฟะพะด ะฟะพัะพะปะบะพะผ (ะะะ ะะขะฌ)
rus_verbs:ะะะะะะะขะฌ{}, // ะฟะพะปะพะถะธะป ะฟะพะด ะดะตัะตะฒะพะผ ะฟะปะฐั (ะะะะะะะขะฌ)
rus_verbs:ะะะะะ ะะขะฌะกะฏ{}, // ะฟะพะด ะดะตัะตะฒััะผะธ ะทะฐะณะพัะตะปัั ะบะพััะตั (ะะะะะ ะะขะฌะกะฏ)
rus_verbs:ะะ ะะะะกะะขะฌะกะฏ{}, // ะฟะพะด ะฝะฐะผะธ ะฟัะพะฝะพัะธะปะธัั ะบัััะธ (ะะ ะะะะกะะขะฌะกะฏ)
rus_verbs:ะะะขะฏะะฃะขะฌะกะฏ{}, // ะฟะพะด ะบะพัะฐะฑะปะตะผ ะฟะพััะฝัะปะธัั ะณะพัั (ะะะขะฏะะฃะขะฌะกะฏ)
rus_verbs:ะะะะะขะฌ{}, // ะฑะตะณะธ ะฟะพะด ัะตัะพะน ััะตะฝะพะน ะฝะพัะธ (ะะะะะขะฌ)
rus_verbs:ะ ะะะะะขะฌะกะฏ{}, // ะฟะพะด ะพะบะฝะพะผ ัะฐะทะดะฐะปะพัั ััะถะตะปะพะต ะดัั
ะฐะฝะธะต (ะ ะะะะะขะฌะกะฏ)
rus_verbs:ะะกะะซะฅะะฃะขะฌ{}, // ะฟะพะด ะฟะพัะพะปะบะพะผ ะฒัะฟัั
ะฝัะปะฐ ััะบะฐั ะปะฐะผะฟะฐ (ะะกะะซะฅะะฃะขะฌ)
rus_verbs:ะกะะะขะ ะะขะฌ{}, // ะฟัะพััะพ ัะผะพััะธัะต ะฟะพะด ะดััะณะธะผ ัะณะปะพะผ (ะกะะะขะ ะะขะฌ ะะะ)
rus_verbs:ะะฃะขะฌ{}, // ัะตะฟะตัั ะฟะพะด ะดะตัะตะฒััะผะธ ะดัะป ะฒะตัะตัะพะบ (ะะฃะขะฌ)
rus_verbs:ะกะะ ะซะขะฌะกะฏ{}, // ะพะฝะพ ะฑััััะพ ัะบััะปะพัั ะฟะพะด ะฒะพะดะพะน (ะกะะ ะซะขะฌะกะฏ ะะะ)
rus_verbs:ะฉะะะะะฃะขะฌ{}, // ะดะฐะปะตะบะพ ะฟะพะด ะฝะธะผะธ ัะตะปะบะฝัะป ะฒััััะตะป (ะฉะะะะะฃะขะฌ)
rus_verbs:ะขะ ะะฉะะขะฌ{}, // ะพัะบะพะปะบะธ ััะตะบะปะฐ ััะตัะฐะปะธ ะฟะพะด ะฝะพะณะฐะผะธ (ะขะ ะะฉะะขะฌ)
rus_verbs:ะ ะะกะะะะะะะขะฌะกะฏ{}, // ะฟะพะด ะฝะธะผะธ ัะฐัะฟะพะปะฐะณะฐะปะธัั ัะฐะทะฝะพัะฒะตัะฝัะต ัะบะฐะผัะธ (ะ ะะกะะะะะะะขะฌะกะฏ)
rus_verbs:ะะซะกะขะฃะะะขะฌ{}, // ะฟะพะด ะฝะพะณััะผะธ ะฒััััะฟะธะปะธ ะบะฐะฟะตะปัะบะธ ะบัะพะฒะธ (ะะซะกะขะฃะะะขะฌ)
rus_verbs:ะะะกะขะฃะะะขะฌ{}, // ะฟะพะด ะบัะฟะพะปะพะผ ะฑะฐะทั ะฝะฐัััะฟะธะปะฐ ัะธัะธะฝะฐ (ะะะกะขะฃะะะขะฌ)
rus_verbs:ะะกะขะะะะะะขะฌะกะฏ{}, // ะฟะพะฒะพะทะบะฐ ะพััะฐะฝะพะฒะธะปะฐัั ะฟะพะด ัะฐะผัะผ ะพะบะฝะพะผ (ะะกะขะะะะะะขะฌะกะฏ)
rus_verbs:ะ ะะกะขะะฏะขะฌ{}, // ะผะฐะณะฐะทะธะฝ ัะฐััะฐัะป ะฟะพะด ะฝะพัะฝัะผ ะดะพะถะดะตะผ (ะ ะะกะขะะฏะขะฌ)
rus_verbs:ะะะะะะขะฌะกะฏ{}, // ะฟะพะด ะฒะพะดะพะน ะดะฒะธะณะฐะปะพัั ะฝะตััะพ ะพะณัะพะผะฝะพะต (ะะะะะะขะฌะกะฏ)
rus_verbs:ะะซะขะฌ{}, // ะฟะพะด ัะฝะตะณะพะผ ะผะพะณัั ะฑััั ััะตัะธะฝั (ะะซะขะฌ)
rus_verbs:ะะะฏะขะฌ{}, // ะฟะพะด ะฝะตะน ะทะธัะปะฐ ัะถะฐัะฝะฐั ัะฐะฝะฐ (ะะะฏะขะฌ)
rus_verbs:ะะะะะะะะขะฌ{}, // ะฟะพะด ััะบะพะน ะฒะพะดะธัะตะปั ะทะฐะทะฒะพะฝะธะป ัะตะปะตัะพะฝ (ะะะะะะะะขะฌ)
rus_verbs:ะะะะะะะขะฌะกะฏ{}, // ะฒะฝะตะทะฐะฟะฝะพ ะฟะพะด ะฝะธะผะธ ะฟะพะบะฐะทะฐะปะฐัั ะฒะพะดะฐ (ะะะะะะะขะฌะกะฏ)
rus_verbs:ะะะะะ ะะขะฌ{}, // ัั
ะพ ะทะฐะผะตัะปะพ ะฟะพะด ะฒััะพะบะธะผ ะฟะพัะพะปะบะพะผ (ะะะะะ ะะขะฌ)
rus_verbs:ะะะะขะ{}, // ะทะฐัะตะผ ะฟะพะด ะบะพัะฐะฑะปะตะผ ะฟะพัะปะฐ ะฟััััะฝั (ะะะะขะ)
rus_verbs:ะะะะกะขะะะะะขะฌ{}, // ะฑะพะณะธ ะฒัะตะณะดะฐ ะดะตะนััะฒััั ะฟะพะด ะผะฐัะบะพะน (ะะะะกะขะะะะะขะฌ)
rus_verbs:ะะะะกะขะะขะฌ{}, // ะผะพะบััะน ะผะตั
ะฑะปะตััะตะป ะฟะพะด ะปัะฝะพะน (ะะะะกะขะะขะฌ)
rus_verbs:ะะะขะะขะฌ{}, // ะฟะพะด ะฝะธะผ ะปะตัะตะปะฐ ัะตัะฐั ะทะตะผะปั (ะะะขะะขะฌ)
rus_verbs:ะกะะะะฃะขะฌะกะฏ{}, // ัะพะดัะพะณะฝัะปัั ะฟะพะด ะฝะพะณะฐะผะธ ะบะฐะผะตะฝะฝัะน ะฟะพะป (ะกะะะะฃะขะฌะกะฏ)
rus_verbs:ะะะะะฃะขะฌ{}, // ัะตัะฒะตัััะน ัะปะตะณะบะฐ ะบะธะฒะฝัะป ะฟะพะด ะบะฐะฟััะพะฝะพะผ (ะะะะะฃะขะฌ)
rus_verbs:ะฃะะะ ะะขะฌ{}, // ะบะพะปะดัะฝ ัะผะตั ะฟะพะด ะณััะดะพะน ะบะฐะผะตะฝะฝัั
ะณะปัะฑ (ะฃะะะ ะะขะฌ)
rus_verbs:ะะะะะซะะะขะฌะกะฏ{}, // ะฒะฝะตะทะฐะฟะฝะพ ะฟะพะด ะฝะพะณะฐะผะธ ะพะบะฐะทัะฒะฐะตััั ะทะฝะฐะบะพะผะฐั ััะพะฟะธะฝะบะฐ (ะะะะะซะะะขะฌะกะฏ)
rus_verbs:ะะกะงะะะะขะฌ{}, // ัะตัะฐั ะปะตะฝัะฐ ะดะพัะพะณะธ ะธััะตะทะฐะปะฐ ะฟะพะด ะฒะพัะพัะฐะผะธ (ะะกะงะะะะขะฌ)
rus_verbs:ะกะะะ ะะะฃะขะฌ{}, // ะณะพะปัะฑัะต ะณะปะฐะทะฐ ัะฒะตัะบะฝัะปะธ ะฟะพะด ะณััััะผะธ ะฑัะพะฒัะผะธ (ะกะะะ ะะะฃะขะฌ)
rus_verbs:ะกะะฏะขะฌ{}, // ะฟะพะด ะฝะธะผ ัะธัะปะฐ ะฑะตะปะฐั ะฟะตะปะตะฝะฐ ะพะฑะปะฐะบะพะฒ (ะกะะฏะขะฌ)
rus_verbs:ะะ ะะะะกะขะะกะฌ{}, // ัะธั
ะธะน ัะผะตั
ะฟัะพะฝะตััั ะฟะพะด ะบัะฟะพะปะพะผ ะทะฐะปะฐ (ะะ ะะะะกะขะะกะฌ)
rus_verbs:ะกะะะะฌะะะขะฌ{}, // ะพะฑะปะพะผะบะธ ััะดะฝะฐ ะผะตะดะปะตะฝะฝะพ ัะบะพะปัะทะธะปะธ ะฟะพะด ะฝะธะผะธ (ะกะะะะฌะะะขะฌ)
rus_verbs:ะะะะฃะขะฌะกะฏ{}, // ะฟะพะด ัะตัะพะน ะบะพะถะตะน ะฒะทะดัะปะธัั ัะฐัั ะผััะบัะปะพะฒ (ะะะะฃะขะฌะกะฏ)
rus_verbs:ะะ ะะะขะ{}, // ะพะฑะปะพะผะพะบ ะพัะปะธัะฝะพ ะฟัะพะนะดะตั ะฟะพะด ะบะพะปะตัะฐะผะธ ัะปะตะฒะฐ (ะะ ะะะขะ)
rus_verbs:ะ ะะะะะะะขะฌะกะฏ{}, // ัะฒะตัะปัะต ะฒะพะปะพัั ัะฐะทะฒะตะฒะฐะปะธัั ะฟะพะด ะดัั
ะฐะฝะธะตะผ ะฒะตััะฐ (ะ ะะะะะะะขะฌะกะฏ)
rus_verbs:ะกะะะ ะะะขะฌ{}, // ะณะปะฐะทะฐ ะพะณะฝะตะผ ัะฒะตัะบะฐะปะธ ะฟะพะด ัะตะผะฝัะผะธ ะฑัะพะฒัะผะธ (ะกะะะ ะะะขะฌ)
rus_verbs:ะะะะะขะฌะกะฏ{}, // ะดะตัะตะฒัะฝะฝัะน ะดะพะบ ะบะฐะทะฐะปัั ะพัะตะฝั ัะฒะตัะดัะผ ะฟะพะด ะผะพะธะผะธ ะฝะพะณะฐะผะธ (ะะะะะขะฌะกะฏ)
rus_verbs:ะะะกะขะะะะขะฌ{}, // ัะตัะฒะตัััะน ะผะฐะณ ัะพัะพะฟะปะธะฒะพ ะฟะพััะฐะฒะธะป ะฟะพะด ะทะตัะบะฐะปะพะผ ัะธัะพะบัั ัะฐัั (ะะะกะขะะะะขะฌ)
rus_verbs:ะะกะขะะะะขะฌะกะฏ{}, // ะทะฐะฟะฐัั ะพััะฐัััั ะฟะพะด ะดะฐะฒะปะตะฝะธะตะผ (ะะกะขะะะะขะฌะกะฏ ะะะ)
rus_verbs:ะะะขะฌ{}, // ะฟัะพััะพ ะผั ะฟะพะด ะทะตะผะปะตะน ะปัะฑะธะผ ะฟะตัั. (ะะะขะฌ ะะะ)
rus_verbs:ะะะฏะะะขะฌะกะฏ{}, // ะฟะพะด ะธั
ะบััะปััะผะธ ะฒะฝะตะทะฐะฟะฝะพ ะฟะพัะฒะธะปัั ะดัะผ. (ะะะฏะะะขะฌะกะฏ ะะะ)
rus_verbs:ะะะะะะขะฌะกะฏ{}, // ะผั ัะฝะพะฒะฐ ะพะบะฐะทะฐะปะธัั ะฟะพะด ัะพะปะฝัะตะผ. (ะะะะะะขะฌะกะฏ ะะะ)
rus_verbs:ะะะะฅะะะะขะฌ{}, // ะผั ะฟะพะดั
ะพะดะธะปะธ ะฟะพะด ะดััะณะธะผ ัะณะปะพะผ? (ะะะะฅะะะะขะฌ ะะะ)
rus_verbs:ะกะะ ะซะะะขะฌะกะฏ{}, // ะบัะพ ะฟะพะด ะฝะตะน ัะบััะฒะฐะตััั? (ะกะะ ะซะะะขะฌะกะฏ ะะะ)
rus_verbs:ะฅะะฎะะะขะฌ{}, // ะฟะพะด ะฝะพะณะฐะผะธ ะะปะปั ั
ะปัะฟะฐะปะฐ ะณััะทั (ะฅะะฎะะะขะฌ ะะะ)
rus_verbs:ะจะะะะขะฌ{}, // ะธั
ะพัััะด ะฒะตัะตะปะพ ัะฐะณะฐะป ะฟะพะด ะดะพะถะดะตะผ ััะพะน ะผัะทัะบะธ. (ะจะะะะขะฌ ะะะ)
rus_verbs:ะขะะงะฌ{}, // ะฟะพะด ะตะต ะฟะพะฒะตัั
ะฝะพัััั ะผะตะดะปะตะฝะฝะพ ัะตะบะปะฐ ััะพััั. (ะขะะงะฌ ะะะ ัะฒะพั)
rus_verbs:ะะงะฃะขะะขะฌะกะฏ{}, // ะผั ะพัััะธะปะธัั ะฟะพะด ััะตะฝะฐะผะธ ะทะฐะผะบะฐ. (ะะงะฃะขะะขะฌะกะฏ ะะะ)
rus_verbs:ะะะะะะกะะะะะขะฌ{}, // ะธั
ะปะฐัั ะฟะพะฑะปะตัะบะธะฒะฐะปะธ ะฟะพะด ัะพะปะฝัะตะผ. (ะะะะะะกะะะะะขะฌ ะะะ)
rus_verbs:ะะ ะะขะฌะกะฏ{}, // ะฟะพะด ััะพะปะฐะผะธ ะดัะฐะปะธัั ะทะฐ ะบะพััะธ ะฟัั. (ะะ ะะขะฌะกะฏ ะะะ)
rus_verbs:ะะะงะะฃะขะฌะกะฏ{}, // ะฟะฐะปัะฑะฐ ะบะฐัะฝัะปะฐัั ั ะฝะฐั ะฟะพะด ะฝะพะณะฐะผะธ. (ะะะงะะฃะะะกะฌ ะะะ)
rus_verbs:ะะ ะะกะะกะขะฌ{}, // ะบะพะฝั ะดะฐะถะต ะฟัะธัะตะป ะฟะพะด ััะถะตะปัะผ ัะตะปะพะผ. (ะะ ะะกะะกะขะฌ ะะะ)
rus_verbs:ะะะขะฌ{}, // ะพะฝะธ ะถะธะฒัั ะฟะพะด ะทะตะผะปะตะน. (ะะะขะฌ ะะะ)
rus_verbs:ะะะะะ ะฃะะะขะฌ{}, // ะฒั ะผะพะถะตัะต ะพะฑะฝะฐััะถะธัั ะตะต ะฟะพะด ะฒะพะดะพะน? (ะะะะะ ะฃะะะขะฌ ะะะ)
rus_verbs:ะะะซะขะฌ{}, // ะััะป ะฟะปัะฒัั ะฟะพะด ะพะฑะปะฐะบะฐะผะธ. (ะะะซะขะฌ ะะะ)
rus_verbs:ะะกะงะะะะฃะขะฌ{}, // ะฟะพัะพะผ ะพะฝะธ ะธััะตะทะปะธ ะฟะพะด ะฒะพะดะพะน. (ะะกะงะะะะฃะขะฌ ะะะ)
rus_verbs:ะดะตัะถะฐัั{}, // ะพััะถะธะต ะฒัะต ะดะตัะถะฐะปะธ ะฟะพะด ััะบะพะน. (ะดะตัะถะฐัั ะะะ)
rus_verbs:ะะกะขะ ะะขะะขะฌะกะฏ{}, // ะพะฝะธ ะฒัััะตัะธะปะธัั ะฟะพะด ะฒะพะดะพะน. (ะะกะขะ ะะขะะขะฌะกะฏ ะะะ)
rus_verbs:ััะฝััั{}, // ะะธัะฐ ััะฝะตั ะฟะพะด ะพะดะตัะปะพะผ
rus_verbs:ะฟะพัะตะฒะตะปะธัััั{}, // ะฟะพัะตะฒะตะปะธัััั ะฟะพะด ะพะดะตัะปะพะผ
rus_verbs:ะทะฐะดะพั
ะฝััััั{}, // ะทะฐะดะพั
ะฝััััั ะฟะพะด ัะปะพะตะผ ัะฝะตะณะฐ
rus_verbs:ะฟะพัะตัั{}, // ะฟะพัะตัั ะฟะพะด ะธะทะฑััะพัะฝัะผ ะดะฐะฒะปะตะฝะธะตะผ
rus_verbs:ััะตะปะตัั{}, // ััะตะปะตัั ะฟะพะด ะทะฐะฒะฐะปะฐะผะธ
rus_verbs:ะผะตััะฐัั{}, // ะผะตััะฐัั ะฟะพะด ะปััะฐะผะธ ัะพัะธัะพะฒ
rus_verbs:ะฟะพะธัะบะฐัั{}, // ะฟะพะธัะบะฐัั ะฟะพะด ะบัะพะฒะฐััั
rus_verbs:ะณัะดะตัั{}, // ะณัะดะตัั ะฟะพะด ะฝะฐะณััะทะบะพะน
rus_verbs:ะฟะพัะธะดะตัั{}, // ะฟะพัะธะดะตัั ะฟะพะด ะฝะฐะฒะตัะพะผ
rus_verbs:ัะบัััััั{}, // ัะบัััััั ะฟะพะด ะฝะฐะฒะตัะพะผ
rus_verbs:ััะธั
ะฝััั{}, // ััะธั
ะฝััั ะฟะพะด ะพะดะตัะปะพะผ
rus_verbs:ะทะฐัะบัะธะฟะตัั{}, // ะทะฐัะบัะธะฟะตัั ะฟะพะด ััะถะตัััั
rus_verbs:ัะตะปะพั
ะฝััััั{}, // ัะตะปะพั
ะฝััััั ะฟะพะด ะพะดะตัะปะพะผ
ะธะฝัะธะฝะธัะธะฒ:ััะตะทะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะณะปะฐะณะพะป:ััะตะทะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ััะตะทะฐัั ะฟะพะด ะบะพัะตะฝั
ะดะตะตะฟัะธัะฐััะธะต:ััะตะทะฐะฒ{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ััะตะทะฐััะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะธะฝัะธะฝะธัะธะฒ:ััะตะทะฐัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ััะตะทะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะดะตะตะฟัะธัะฐััะธะต:ััะตะทะฐั{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ััะตะทะฐะฒัะธะน{ ะฒะธะด:ัะพะฒะตัั },
rus_verbs:ะฟะพะฝะธะผะฐัััั{}, // ะฟะพะฝะธะผะฐัััั ะฟะพะด ััะฟะตั
ะพะผ
rus_verbs:ะฟะพะดัะฐะทัะผะตะฒะฐัััั{}, // ะฟะพะดัะฐะทัะผะตะฒะฐัััั ะฟะพะด ะฟัะฐะฒะธะปัะฝัะผ ัะตัะตะฝะธะตะผ
rus_verbs:ะฟัะพะผะพะบะฝััั{}, // ะฟัะพะผะพะบะฝััั ะฟะพะด ะฟัะพะปะธะฒะฝัะผ ะดะพะถะดะตะผ
rus_verbs:ะทะฐัะพัะฐัั{}, // ะทะฐัะพัะฐัั ะฟะพะด ะปะพะถะตัะบะพะน
rus_verbs:ะฟะพะดะฟะธัะฐัััั{}, // ะฟะพะดะฟะธัะฐัััั ะฟะพะด ะฒะพะทะทะฒะฐะฝะธะตะผ
rus_verbs:ัะบััะฒะฐัััั{}, // ัะบััะฒะฐัััั ะฟะพะด ะฝะฐะฒะตัะพะผ
rus_verbs:ะทะฐะฟัั
ัะตัั{}, // ะทะฐะฟัั
ัะตัั ะฟะพะด ะพะดะตัะปะพะผ
rus_verbs:ะผะพะบะฝััั{}, // ะผะพะบะฝััั ะฟะพะด ะปะพะถะดะตะผ
rus_verbs:ัะณะธะฑะฐัััั{}, // ัะณะธะฑะฐัััั ะฟะพะด ััะถะตัััั ัะฝะตะณะฐ
rus_verbs:ะฝะฐะผะพะบะฝััั{}, // ะฝะฐะผะพะบะฝััั ะฟะพะด ะดะพะถะดะตะผ
rus_verbs:ะฟะพะดะฟะธััะฒะฐัััั{}, // ะฟะพะดะฟะธััะฒะฐัััั ะฟะพะด ะพะฑัะฐัะตะฝะธะตะผ
rus_verbs:ัะฐัะฐั
ัะตัั{}, // ัะฐัะฐั
ัะตัั ะฟะพะด ะพะบะฝะฐะผะธ
ะธะฝัะธะฝะธัะธะฒ:ะฝะฐั
ะพะดะธัััั{ะฒะธะด:ะฝะตัะพะฒะตัั}, ะณะปะฐะณะพะป:ะฝะฐั
ะพะดะธัััั{ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะะฝะฐ ัะถะต ะฝะตัะบะพะปัะบะพ ะปะตั ะฝะฐั
ะพะดะธััั ะฟะพะด ะฝะฐะฑะปัะดะตะฝะธะตะผ ะฒัะฐัะฐ.
ะดะตะตะฟัะธัะฐััะธะต:ะฝะฐั
ะพะดััั{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐั
ะพะดะธะฒัะธะนัั{ะฒะธะด:ะฝะตัะพะฒะตัั}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐั
ะพะดััะธะนัั{},
rus_verbs:ะปะตะถะฐัั{}, // ะปะตะถะฐัั ะฟะพะด ะบะฐะฟะตะปัะฝะธัะตะน
rus_verbs:ะฒัะผะพะบะฐัั{}, // ะฒัะผะพะบะฐัั ะฟะพะด ะดะพะถะดัะผ
rus_verbs:ะฒัะผะพะบะฝััั{}, // ะฒัะผะพะบะฝััั ะฟะพะด ะดะพะถะดัะผ
rus_verbs:ะฟัะพะฒะพััะฐัั{}, // ะฟัะพะฒะพััะฐัั ะฟะพะด ะฝะพั
rus_verbs:ั
ะผัะบะฝััั{}, // ั
ะผัะบะฝััั ะฟะพะด ะฝะพั
rus_verbs:ะพัััะบะฐัั{}, // ะพัััะบะฐัั ะฟะพะด ะบัะพะฒะฐััั
rus_verbs:ะดัะพะณะฝััั{}, // ะดัะพะณะฝััั ะฟะพะด ัะดะฐัะฐะผะธ
rus_verbs:ะฟัะพัะฒะปััััั{}, // ะฟัะพัะฒะปััััั ะฟะพะด ะฝะฐะณััะทะบะพะน
rus_verbs:ัะดะตัะถะฐัั{}, // ัะดะตัะถะฐัั ะฟะพะด ะบะพะฝััะพะปะตะผ
rus_verbs:ะปะพะถะธัััั{}, // ะปะพะถะธัััั ะฟะพะด ะบะปะธะตะฝัะฐ
rus_verbs:ัะฐััั{}, // ัะฐััั ะฟะพะด ะฒะตัะตะฝะฝะธะผ ัะพะปะฝัะตะผ
rus_verbs:ะฟะพะบะฐัะธัััั{}, // ะฟะพะบะฐัะธัััั ะฟะพะด ะพัะบะพั
rus_verbs:ะปะตัั{}, // ะพะฝ ะปะตะณ ะฟะพะด ะฝะฐะฒะตัะพะผ
rus_verbs:ะธะดัะธ{}, // ะธะดัะธ ะฟะพะด ะดะพะถะดะตะผ
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะธะทะฒะตััะฝัะน{}, // ะะฝ ะธะทะฒะตััะตะฝ ะฟะพะด ััะธะผ ะธะผะตะฝะตะผ.
rus_verbs:ััะพััั{}, // ะฏัะธะบ ััะพะธั ะฟะพะด ััะพะปะพะผ.
rus_verbs:ะพััััะฟะธัั{}, // ะัะฐะณ ะพััััะฟะธะป ะฟะพะด ัะดะฐัะฐะผะธ ะฝะฐัะธั
ะฒะพะนัะบ.
rus_verbs:ัะฐัะฐะฟะฐัััั{}, // ะััั ัะฐัะฐะฟะฐะตััั ะฟะพะด ะฟะพะปะพะผ.
rus_verbs:ัะฟะฐัั{}, // ะทะฐัั ัะฟะพะบะพะนะฝะพ ัะฟะฐะป ั ัะตะฑั ะฟะพะด ะบัััะพะผ
rus_verbs:ะทะฐะณะพัะฐัั{}, // ะผั ะทะฐะณะพัะฐะตะผ ะฟะพะด ัะพะปะฝัะตะผ
ะะ_ะะะค(ะผััั), // ะผััั ััะบะธ ะฟะพะด ัััััะน ะฒะพะดั
ะะ_ะะะค(ะทะฐะบะพะฟะฐัั),
ะะ_ะะะค(ัะฟัััะฐัั),
ะะ_ะะะค(ะฟัััะฐัั),
ะะ_ะะะค(ะฟะตัะตะฟัััะฐัั)
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะะ_ัะฒะพั ะฟัะตะดะปะพะณ:ะฟะพะด{} *:*{ ะฟะฐะดะตะถ:ัะฒะพั } }
then return true
}
// ะดะปั ะณะปะฐะณะพะปะพะฒ ะฒะฝะต ัะฟะธัะบะฐ - ะทะฐะฟัะตัะฐะตะผ.
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฟะพะด{} *:*{ ะฟะฐะดะตะถ:ัะฒะพั } }
then return false,-10
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฟะพะด{} *:*{} }
then return false,-11
}
#endregion ะัะตะดะปะพะณ_ะะะ
*/
#region ะัะตะดะปะพะณ_ะะ
// -------------- ะะ ะะะะะ 'ะะ' -----------------------
wordentry_set ะะป_ะะ_ะฟัะตะดะป=
{
rus_verbs:ะกะะะะะขะะะฌะกะขะะะะะขะฌ{}, // ะะฑ ะธั
ะฟัะธัััััะฒะธะธ ัะฒะธะดะตัะตะปัััะฒะพะฒะฐะปะพ ะปะธัั ัััะบะปะพะต ะฟััะฟััะฝะพะต ะฟััะฝะพ, ะฟัะพัััะฟะฐะฒัะตะต ะฝะฐ ะบะฐะผะฝะต. (ะกะะะะะขะะะฌะกะขะะะะะขะฌ)
rus_verbs:ะะะะฃะะะขะฌะกะฏ{}, // ะัะพะผััะปะตะฝะฝัะต ะณะธะณะฐะฝัั ะทะฐะดัะผะฐะปะธัั ะพะฑ ัะบะพะปะพะณะธะธ (ะะะะฃะะะขะฌะกะฏ)
rus_verbs:ะกะะ ะะกะะขะฌ{}, // ะะฝ ัะฟัะพัะธะป ะฝะตัะบะพะปัะบะธั
ะธะท ะฟะปัะถะฝะธะบะพะฒ ะพะฑ ะธั
ะบะฐะถััะตะนัั ะฒัะตะพะฑัะตะน ัะฝะพััะธ. (ะกะะ ะะกะะขะฌ)
rus_verbs:ัะฟัะฐัะธะฒะฐัั{}, // ะบะฐะบ ัั ะผะพะถะตัั ะตัะต ัะฟัะฐัะธะฒะฐัั ั ะผะตะฝั ะพะฑ ััะพะผ?
rus_verbs:ะทะฐะฑัะฒะฐัั{}, // ะั ะฝะต ะผะพะถะตะผ ะทะฐะฑัะฒะฐัั ะพะฑ ะธั
ััะฐััะธ.
rus_verbs:ะะะะะขะฌ{}, // ัะตะฟะตัั ะพะฑ ััะพะผ ะผะพะถะฝะพ ะปะธัั ะณะฐะดะฐัั (ะะะะะขะฌ)
rus_verbs:ะะะะะะะขะฌ{}, // ะัะฐะดะพะฝะฐัะฐะปัะฝะธะบ , ะฒััััะฟะฐั ั ะพะฑะทะพัะพะผ ะพัะฝะพะฒะฝัั
ะณะพัะพะดัะบะธั
ัะพะฑััะธะน , ะฟะพะฒะตะดะฐะป ะพะฑ ััะพะผ ะดะตะฟััะฐัะฐะผ (ะะะะะะะขะฌ ะะ)
rus_verbs:ะกะะะะฉะะขะฌ{}, // ะัะฐะฝ ัะพะพะฑัะธะป ะะะะะขะญ ะพะฑ ััะบะพัะตะฝะธะธ ะพะฑะพะณะฐัะตะฝะธั ััะฐะฝะฐ (ะกะะะะฉะะขะฌ)
rus_verbs:ะะะฏะะะขะฌ{}, // ะะฑ ะธั
ััะฟะตัะฝะพะผ ะพะบะพะฝัะฐะฝะธะธ ะทะฐัะฒะธะป ะณะตะฝะตัะฐะปัะฝัะน ะดะธัะตะบัะพั (ะะะฏะะะขะฌ ะะ)
rus_verbs:ัะปััะฐัั{}, // ะดะฐะถะต ะพะฝะธ ัะปััะฐะปะธ ะพะฑ ััะพะผ ัะตะปะพะฒะตะบะต. (ะกะะซะจะะขะฌ ะะ)
rus_verbs:ะะะะะะะขะฌ{}, // ะฒะตัะฝัะฒัะธะตัั ัะฐะทะฒะตะดัะธะบะธ ะดะพะปะพะถะธะปะธ ะพะฑ ัะฒะธะดะตะฝะฝะพะผ (ะะะะะะะขะฌ ะะ)
rus_verbs:ะะะะะะะ ะะขะฌ{}, // ะดะฐะฒะฐะน ะฟะพะณะพะฒะพัะธะผ ะพะฑ ััะพะผ. (ะะะะะะะ ะะขะฌ ะะ)
rus_verbs:ะะะะะะะขะฌะกะฏ{}, // ะพะฑ ะพััะฐะปัะฝะพะผ ะฝะตัััะดะฝะพ ะดะพะณะฐะดะฐัััั. (ะะะะะะะขะฌะกะฏ ะะ)
rus_verbs:ะะะะะะะขะะขะฌะกะฏ{}, // ะพะฑะตัะฐะป ะพะฑะพ ะฒัะตะผ ะฟะพะทะฐะฑะพัะธัััั. (ะะะะะะะขะะขะฌะกะฏ ะะ)
rus_verbs:ะะะะะะซะขะฌ{}, // ะจััะฐ ะฟะพะทะฐะฑัะป ะพะฑะพ ะฒัะตะผ. (ะะะะะะซะขะฌ ะะ)
rus_verbs:ะฒัะฟะพะผะธะฝะฐัั{}, // ะะฟะพัะปะตะดััะฒะธะธ ะพะฝ ะฝะต ัะฐะท ะฒัะฟะพะผะธะฝะฐะป ะพะฑ ััะพะผ ะฟัะธะบะปััะตะฝะธะธ. (ะฒัะฟะพะผะธะฝะฐัั ะพะฑ)
rus_verbs:ัะพะพะฑัะฐัั{}, // ะะฐะทะตัะฐ ัะพะพะฑัะฐะตั ะพะฑ ะพัะบัััะธะธ ัะตััะธะธ ะฟะฐัะปะฐะผะตะฝัะฐ. (ัะพะพะฑัะฐัั ะพะฑ)
rus_verbs:ะฟัะพัะธัั{}, // ะผั ะฟัะพัะธะปะธ ะพะฑ ะพัััะพัะบะต ะฟะปะฐัะตะถะตะน (ะฟัะพัะธัั ะะ)
rus_verbs:ะะะขะฌ{}, // ััะฐ ะถะต ะดะตะฒััะบะฐ ะฟะตะปะฐ ะพะฑะพ ะฒัะตะผ ัะพะฒะตััะตะฝะฝะพ ะพัะบัััะพ. (ะะะขะฌ ะะ)
rus_verbs:ัะบะฐะทะฐัั{}, // ัั ัะบะฐะถะตัั ะพะฑ ััะพะผ ะบะฐะฟะธัะฐะฝั? (ัะบะฐะทะฐัั ะะ)
rus_verbs:ะทะฝะฐัั{}, // ะฑั ั
ะพัะตะปะพัั ะทะฝะฐัั ะบะฐะบ ะผะพะถะฝะพ ะฑะพะปััะต ะพะฑ ััะพะผ ัะฐะนะพะฝะต.
rus_verbs:ะบัะธัะฐัั{}, // ะัะต ะณะฐะทะตัั ะบัะธัะฐั ะพะฑ ััะพะผ ัะพะฑััะธะธ.
rus_verbs:ัะพะฒะตัะพะฒะฐัััั{}, // ะะฝะฐ ะพะฑะพ ะฒััะผ ัะพะฒะตััะตััั ั ะผะฐัะตััั.
rus_verbs:ะณะพะฒะพัะธัััั{}, // ะพะฑ ะพััะฐะปัะฝะพะผ ะณะพะฒะพัะธะปะพัั ะปะตะณะบะพ.
rus_verbs:ะฟะพะดัะผะฐัั{}, // ะฝัะถะฝะพ ะบัะตะฟะบะพ ะพะฑะพ ะฒัะตะผ ะฟะพะดัะผะฐัั.
rus_verbs:ะฝะฐะฟะพะผะฝะธัั{}, // ัะตัะฝัะน ะดัะผ ะฝะฐะฟะพะผะฝะธะป ะพะฑ ะพะฟะฐัะฝะพััะธ.
rus_verbs:ะทะฐะฑััั{}, // ะทะฐะฑัะดั ะพะฑ ััะพะน ัะพัะบะพัะธ.
rus_verbs:ะดัะผะฐัั{}, // ะฟัะธั
ะพะดะธััั ะพะฑะพ ะฒัะตะผ ะดัะผะฐัั ัะฐะผะพะน.
rus_verbs:ะพััะฐะฟะพััะพะฒะฐัั{}, // ะพััะฐะฟะพััะพะฒะฐัั ะพะฑ ััะฟะตั
ะฐั
rus_verbs:ะธะฝัะพัะผะธัะพะฒะฐัั{}, // ะธะฝัะพัะผะธัะพะฒะฐัั ะพะฑ ะธะทะผะตะฝะตะฝะธัั
rus_verbs:ะพะฟะพะฒะตััะธัั{}, // ะพะฟะพะฒะตััะธัั ะพะฑ ะพัะบะฐะทะต
rus_verbs:ัะฑะธะฒะฐัััั{}, // ัะฑะธะฒะฐัััั ะพะฑ ััะตะฝั
rus_verbs:ัะฐััะธะฑะธัั{}, // ัะฐััะธะฑะธัั ะพะฑ ััะตะฝั
rus_verbs:ะทะฐะณะพะฒะพัะธัั{}, // ะทะฐะณะพะฒะพัะธัั ะพะฑ ะพะฟะปะฐัะต
rus_verbs:ะพัะพะทะฒะฐัััั{}, // ะะฝ ะพัะพะทะฒะฐะปัั ะพะฑ ััะพะน ะบะฝะธะณะต ั ะฑะพะปััะพะน ะฟะพั
ะฒะฐะปะพะน.
rus_verbs:ะฟะพะฟัะพัะธัั{}, // ะฟะพะฟัะพัะธัั ะพะฑ ััะปัะณะต
rus_verbs:ะพะฑััะฒะธัั{}, // ะพะฑััะฒะธัั ะพะฑ ะพัััะฐะฒะบะต
rus_verbs:ะฟัะตะดัะฟัะตะดะธัั{}, // ะฟัะตะดัะฟัะตะดะธัั ะพะฑ ะฐะฒะฐัะธะธ
rus_verbs:ะฟัะตะดัะฟัะตะถะดะฐัั{}, // ะฟัะตะดัะฟัะตะถะดะฐัั ะพะฑ ะพะฟะฐัะฝะพััะธ
rus_verbs:ัะฒะตัะดะธัั{}, // ัะฒะตัะดะธัั ะพะฑ ะพะฑัะทะฐะฝะฝะพัััั
rus_verbs:ะทะฐัะฒะปััั{}, // ะทะฐัะฒะปััั ะพะฑ ัะบัะฟะตัะธะผะตะฝัะฐะปัะฝะพะผ ะฟะพะดัะฒะตัะถะดะตะฝะธะธ
rus_verbs:ัะฐัััะถะดะฐัั{}, // ัะฐัััะถะดะฐัั ะพะฑ ะฐะฑัััะฐะบัะฝัั
ะธะดะตัั
rus_verbs:ะณะพะฒะพัะธัั{}, // ะะต ะณะพะฒะพัะธัะต ะพะฑ ััะพะผ ะฒ ะฟัะธัััััะฒะธะธ ััะตััะธั
ะปะธั.
rus_verbs:ัะธัะฐัั{}, // ะพะฝ ัะธัะฐะป ะพะฑ ััะพะผ ะฒ ะถััะฝะฐะปะต
rus_verbs:ะฟัะพัะธัะฐัั{}, // ะพะฝ ัะธัะฐะป ะพะฑ ััะพะผ ะฒ ััะตะฑะฝะธะบะต
rus_verbs:ัะทะฝะฐัั{}, // ะพะฝ ัะทะฝะฐะป ะพะฑ ััะพะผ ะธะท ัะธะปัะผะพะฒ
rus_verbs:ัะฐััะบะฐะทะฐัั{}, // ัะฐััะบะฐะทะฐัั ะพะฑ ัะบะทะฐะผะตะฝะฐั
rus_verbs:ัะฐััะบะฐะทัะฒะฐัั{},
rus_verbs:ะดะพะณะพะฒะพัะธัััั{}, // ะดะพะณะพะฒะพัะธัััั ะพะฑ ะพะฟะปะฐัะต
rus_verbs:ะดะพะณะพะฒะฐัะธะฒะฐัััั{}, // ะดะพะณะพะฒะฐัะธะฒะฐัััั ะพะฑ ะพะฑะผะตะฝะต
rus_verbs:ะฑะพะปัะฐัั{}, // ะะต ะฑะพะปัะฐะน ะพะฑ ััะพะผ!
rus_verbs:ะฟัะพะฑะพะปัะฐัััั{}, // ะะต ะฟัะพะฑะพะปัะฐะนัั ะพะฑ ััะพะผ!
rus_verbs:ะทะฐะฑะพัะธัััั{}, // ะบัะพ ะทะฐะฑะพัะธััั ะพะฑ ััะตะณัะปะธัะพะฒะฐะฝะธะธ
rus_verbs:ะฑะตัะฟะพะบะพะธัััั{}, // ะฒั ะฑะตัะฟะพะบะพะธัะตัั ะพะฑ ะพะฑะพัะพะฝะต
rus_verbs:ะฟะพะผะฝะธัั{}, // ะฒัะตะผ ัะพะฒะตััั ะพะฑ ััะพะผ ะฟะพะผะฝะธัั
rus_verbs:ะผะตััะฐัั{} // ะะตััะฐัั ะพะฑ ััะฟะตั
ะต
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะ_ะฟัะตะดะป ะฟัะตะดะปะพะณ:ะพะฑ{} *:*{ ะฟะฐะดะตะถ:ะฟัะตะดะป } }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะพ{} @regex("[a-z]+[0-9]*") }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะพะฑ{} @regex("[a-z]+[0-9]*") }
then return true
}
// ะพััะฐะปัะฝัะต ะณะปะฐะณะพะปั ะฝะต ะผะพะณัั ัะฒัะทัะฒะฐัััั
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะพะฑ{} *:*{ ะฟะฐะดะตะถ:ะฟัะตะดะป } }
then return false, -4
}
wordentry_set ะะป_ะะ_ะฒะธะฝ=
{
rus_verbs:ะกะะะะะขะฌ{}, // ะฟะพัะพะผ ะพะฑ ะบะพะปะตะฝะพ ัะปะพะผะฐะป (ะกะะะะะขะฌ)
rus_verbs:ัะฐะทะฑะธัั{}, // ัั ัะฐะทะฑะธะป ัะตะบั ะพะฑ ัะณะพะป ััะธะบะฐ. (ะ ะะะะะขะฌ ะะ)
rus_verbs:ะพะฟะตัะตัััั{}, // ะะฝ ะพะฟัััั ะพะฑ ััะตะฝั.
rus_verbs:ะพะฟะธัะฐัััั{},
rus_verbs:ะฟะพััััะฐัั{}, // ะฟะพััััะฐะป ะปะฑะพะผ ะพะฑ ะฟะพะป.
rus_verbs:ัะดะฐัะธัััั{}, // ะฑัััะปะบะฐ ะณะปัั
ะพ ัะดะฐัะธะปะฐัั ะพะฑ ะทะตะผะปั.
rus_verbs:ัะฑะธะฒะฐัััั{}, // ัะฑะธะฒะฐัััั ะพะฑ ััะตะฝั
rus_verbs:ัะฐััะธะฑะธัั{}, // ัะฐััะธะฑะธัั ะพะฑ ััะตะฝั
rus_verbs:ัะฐัะฐะฟะฐัััั{} // ะะฝะธัะต ะปะพะดะบะธ ัะฐัะฐะฟะฐะปะพัั ะพะฑะพ ััะพ-ัะพ.
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะ_ะฒะธะฝ ะฟัะตะดะปะพะณ:ะพะฑ{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะพะฑ{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return false,-4
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะพะฑ{} *:*{} }
then return false,-5
}
#endregion ะัะตะดะปะพะณ_ะะ
#region ะัะตะดะปะพะณ_ะ
// ------------------- ะก ะะ ะะะะะะะ 'ะ' ----------------------
wordentry_set ะะป_ะ_ะะธะฝ={
rus_verbs:ัะผัะบะฝััั{}, // ะะน ั
ะพัะตะปะพัั ัะผัะบะฝััั ะธะผะธ ะพ ััะตะฝั.
rus_verbs:ะฑะพะปัะฐัั{}, // ะะพะปัะฐะปะธ ัะฐัะต ะฒัะตะณะพ ะพ ะฟััััะบะฐั
.
rus_verbs:ัะฒะฐัะบะฝััั{}, // ะะฝะฐ ัะฒะฐัะบะฝัะปะฐ ัััะฑะบะพะน ะพ ัััะฐะณ.
rus_verbs:ะพะฟะธัะฐัััั{}, // ะะฐัั ะฟัะธะฟะพะดะฝัะปะฐัั, ั ัััะดะพะผ ะพะฟะธัะฐััั ะพ ััะพะป.
rus_verbs:ะฑะฐั
ะฝััััั{}, // ะะฐั
ะฝััััั ะณะพะปะพะฒะพะน ะพ ััะพะป.
rus_verbs:ะะซะขะะ ะะขะฌ{}, // ะััะฐัะธ ะฝะพะถ ะธ ะฒัััะธ ะตะณะพ ะพ ััะฐะฒั. (ะะซะขะะ ะะขะฌ/ะะซะขะะ ะะขะฌ)
rus_verbs:ะะซะขะะ ะะขะฌ{}, //
rus_verbs:ะ ะะะะะขะฌะกะฏ{}, // ะัะธะฑะพะน ะฝะฐะบะฐัะธะปัั ะธ ั ััะผะพะผ ัะฐะทะฑะธะปัั ะพ ะฑะตะปัะน ะฟะตัะพะบ. (ะ ะะะะะขะฌะกะฏ)
rus_verbs:ะกะขะฃะะะฃะขะฌ{}, // ะกะตัะดัะต ะตะณะพ ะณะปัั
ะพ ัััะบะฝัะปะพ ะพ ะณััะดะฝัั ะบะพััั (ะกะขะฃะะะฃะขะฌ)
rus_verbs:ะะฏะะะะฃะขะฌ{}, // ะะฝ ะบะธะฝัะปัั ะฝะฐะทะตะผั, ะฟะพะบะฐัะธะปัั, ะธ ะบะพะฟัะต ะปัะทะณะฝัะปะพ ะพ ััะตะฝั. (ะะฏะะะะฃะขะฌ/ะะฏะะะะขะฌ)
rus_verbs:ะะฏะะะะขะฌ{}, //
rus_verbs:ะทะฒะตะฝะตัั{}, // ัััะตะปั ัะถะต ะทะฒะตะฝะตะปะธ ะพ ะฟััััั ะบะปะตัะบะธ
rus_verbs:ะฉะะะะะฃะขะฌ{}, // ะบะฐะผะตะฝั ัะตะปะบะฝัะป ะพ ัะบะฐะปั (ะฉะะะะะฃะขะฌ)
rus_verbs:ะะะขะฌ{}, // ะฒะพะปะฝะฐ ะฑัะตั ะพ ะฑะตัะตะณ (ะะะขะฌ)
rus_verbs:ะะะะะะะะขะฌ{}, // ะทะฐะทะฒะตะฝะตะปะธ ะผะตัะธ ะพ ัะธัั (ะะะะะะะะขะฌ)
rus_verbs:ะบะพะปะพัะธัััั{}, // ัะตัะดัะต ะตะณะพ ะบะพะปะพัะธะปะพัั ะพ ัะตะฑัะฐ
rus_verbs:ััััะฐัั{}, // ะณะปัั
ะพ ััััะฐะปะธ ะพ ัะธัั ััะบะพััะธ ะผะตัะตะน.
rus_verbs:ะฑะธัััั{}, // ะฑะธัััั ะณะพะปะพะฒะพะน ะพ ััะตะฝั? (ะฑะธัััั ะพ)
rus_verbs:ัะดะฐัะธัั{}, // ะฒะพะดะฐ ัะดะฐัะธะปะฐ ะตะณะพ ะพ ััะตะฝั ะบะพัะธะดะพัะฐ. (ัะดะฐัะธะปะฐ ะพ)
rus_verbs:ัะฐะทะฑะธะฒะฐัััั{}, // ะฒะพะปะฝั ัะฐะทะฑะธะฒะฐะปะธัั ะพ ัะบะฐะปั
rus_verbs:ัะฐะทะฑะธะฒะฐัั{}, // ะ ะฐะทะฑะธะฒะฐะตั ะณะพะปะพะฒั ะพ ะฟััััั ะบะปะตัะบะธ.
rus_verbs:ะพะฑะปะพะบะพัะธัััั{}, // ะพะฑะปะพะบะพัะธัััั ะพ ััะตะฝั
rus_verbs:ัะพัะธัั{}, // ัะพัะธัั ะพ ัะพัะธะปัะฝัะน ะบะฐะผะตะฝั
rus_verbs:ัะฟะพััะบะฐัััั{}, // ัะฟะพััะบะฐัััั ะพ ัะฟัััะฐะฒัะธะนัั ะฒ ััะฐะฒะต ะฟะตะฝั
rus_verbs:ะฟะพัะตัะตัััั{}, // ะฟะพัะตัะตัััั ะพ ะดะตัะตะฒะพ
rus_verbs:ััะธะฑะธัััั{}, // ััะธะฑะธัััั ะพ ะดะตัะตะฒะพ
rus_verbs:ัะตัะตัััั{}, // ัะตัะตัััั ะพ ััะฒะพะป
rus_verbs:ัะผัะบะฝััััั{}, // ัะผัะบะฝััััั ะพ ะทะตะผะปั
rus_verbs:ัะฑะธะฒะฐัััั{}, // ัะฑะธะฒะฐัััั ะพะฑ ััะตะฝั
rus_verbs:ัะฐััะธะฑะธัั{}, // ัะฐััะธะฑะธัั ะพะฑ ััะตะฝั
rus_verbs:ัะตัะตัั{}, // ัะตัะตัั ะพ ะบะฐะผะตะฝั
rus_verbs:ะฟะพัะตัะตัั{}, // ะฟะพัะตัะตัั ะพ ะบะพะปะตะฝะพ
rus_verbs:ัะดะฐัะธัััั{}, // ัะดะฐัะธัััั ะพ ะบัะฐะน
rus_verbs:ัะฟะพัะบะฝััััั{}, // ัะฟะพัะบะฝััััั ะพ ะบะฐะผะตะฝั
rus_verbs:ะทะฐะฟะฝััััั{}, // ะทะฐะฟะฝััััั ะพ ะบะฐะผะตะฝั
rus_verbs:ะทะฐะฟะธะฝะฐัััั{}, // ะทะฐะฟะธะฝะฐัััั ะพ ะบะฐะผะฝะธ
rus_verbs:ัะดะฐัััััั{}, // ัะดะฐัััััั ะพ ะฑะพััะธะบ
rus_verbs:ัััะบะฝััััั{}, // ัััะบะฝััััั ะพ ะฑะพััะธะบ
rus_verbs:ัััะบะฐัััั{}, // ัััะบะฐัััั ะพ ะฑะพััะธะบ
rus_verbs:ะพะฟะตัะตัััั{}, // ะะฝ ะพะฟัััั ะปะพะบััะผะธ ะพ ััะพะป.
rus_verbs:ะฟะปะตัะบะฐัััั{} // ะะพะดะฐ ะฟะปะตัะตััั ะพ ะฑะตัะตะณ.
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะ_ะะธะฝ ะฟัะตะดะปะพะณ:ะพ{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะพ{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return false,-5
}
wordentry_set ะะป_ะ_ะฟัะตะดะป={
rus_verbs:ะะ ะะงะะขะฌ{}, // ะพะฝะฐ ะบัะธัะฐะปะฐ ะพ ัะผะตััะธ! (ะะ ะะงะะขะฌ)
rus_verbs:ะ ะะกะกะะ ะะกะะขะฌ{}, // ะฏ ัะฐััะฟัะพัะธะป ะพ ะฝะตะผ ะฝะตัะบะพะปัะบะธั
ะณะพัะพะถะฐะฝ. (ะ ะะกะกะะ ะะกะะขะฌ/ะ ะะกะกะะ ะะจะะะะขะฌ)
rus_verbs:ะ ะะกะกะะ ะะจะะะะขะฌ{}, //
rus_verbs:ัะปััะฐัั{}, // ัั ะฑัะดะตัั ัะปััะฐัั ะพ ะฝะธั
?
rus_verbs:ะฒัะฟะพะผะธะฝะฐัั{}, // ะฒัะฟะพะผะธะฝะฐัั ะพ ัะพะผ ัะฐะทะณะพะฒะพัะต ะตะผั ะฑัะปะพ ะฝะตะฟัะธััะฝะพ
rus_verbs:ะะะะงะะขะฌ{}, // ะ ััะผ ะผะพะปัะฐั ะดะตะฒััะบะธ (ะะะะงะะขะฌ)
rus_verbs:ะะะะะะขะฌ{}, // ะพะฝะฐ ะฟะปะฐะบะฐะปะฐ ะพ ัะตะฑะต (ะะะะะะขะฌ)
rus_verbs:ัะปะพะถะธัั{}, // ะพ ะฒะฐั ัะปะพะถะตะฝั ะปะตะณะตะฝะดั
rus_verbs:ะะะะะะะะขะฌะกะฏ{}, // ะฏ ะฒะพะปะฝัััั ะพ ัะพะผ, ััะพ ััะพ-ัะพ ัะตัััะทะฝะพ ะฟะพัะปะพ ะฝะต ัะฐะบ (ะะะะะะะะขะฌะกะฏ ะ)
rus_verbs:ะฃะะะะฏะะฃะขะฌ{}, // ัะฟะพะผัะฝัะป ะพ ะฝะฐะผะตัะตะฝะธะธ ะบะพะผะฐะฝะดั ะฟัะธะพะฑัะตััะธ ะฝะตัะบะพะปัะบะพ ะฝะพะฒัั
ัััะฑะพะปะธััะพะฒ (ะฃะะะะฏะะฃะขะฌ ะ)
rus_verbs:ะะขะงะะขะซะะะขะฌะกะฏ{}, // ะกัะดะตะฑะฝัะต ะฟัะธััะฐะฒั ะฟัะพะดะพะปะถะฐัั ะพััะธััะฒะฐัััั ะพ ะฑะพััะฑะต ั ะฝะตะฟะปะฐัะตะปััะธะบะฐะผะธ (ะะขะงะะขะซะะะขะฌะกะฏ ะ)
rus_verbs:ะะะะะะะขะฌ{}, // ะฟัะพะฒะตััะธ ััะฐัะตะปัะฝะพะต ัะฐััะปะตะดะพะฒะฐะฝะธะต ะฒะทััะฒะฐ ะฒ ะผะฐัััััะฝะพะผ ัะฐะบัะธ ะฒะพ ะะปะฐะดะธะบะฐะฒะบะฐะทะต ะธ ะดะพะปะพะถะธัั ะพ ัะตะทัะปััะฐัะฐั
(ะะะะะะะขะฌ ะ)
rus_verbs:ะะ ะะะะะขะะขะฌ{}, // ะฟัะฐะฒะธัะตะปัััะฒะพ ัััะฐะฝั ะฑะพะปััะต ะฟัะพะฑะพะปัะฐะปะพ ะพ ะฒะพะตะฝะฝะพะน ัะตัะพัะผะต (ะะ ะะะะะขะะขะฌ ะ)
rus_verbs:ะะะะะขะะขะฌะกะฏ{}, // ะงะตัะฒะตััั ัะพััะธัะฝ ะทะฐะฑะพััััั ะพ ะทะดะพัะพะฒัะต ะฟััะตะผ ะฟัะพัะผะพััะฐ ัะตะปะตะฒะธะทะพัะฐ (ะะะะะขะะขะฌะกะฏ ะ)
rus_verbs:ะะ ะะะะะะ ะะะะขะฌ{}, // ะั ะธัะพะฝะธะทะธััะตัะต ะพ ะฝะพััะฐะปัะณะธะธ ะฟะพ ัะตะผ ะฒัะตะผะตะฝะตะผ (ะะ ะะะะะะ ะะะะขะฌ ะ)
rus_verbs:ะกะะะะะะะะะ ะะะะขะฌ{}, // ะัะธะทะธั ัะตะฝ ะฝะฐ ะฟัะพะดัะบัั ะฟะธัะฐะฝะธั ัะธะณะฝะฐะปะธะทะธััะตั ะพ ะฝะตะผะธะฝัะตะผะพะน ะณะธะฟะตัะธะฝัะปััะธะธ (ะกะะะะะะะะะ ะะะะขะฌ ะ)
rus_verbs:ะกะะ ะะกะะขะฌ{}, // ะะฝ ัะฟัะพัะธะป ะพ ะผะพัะผ ะทะดะพัะพะฒัะต. (ะกะะ ะะกะะขะฌ ะ)
rus_verbs:ะะะะะะะะขะฌ{}, // ะฑะพะปัะฝะพะน ะทัะฑ ะพะฟััั ะฝะฐะฟะพะผะฝะธะป ะพ ัะตะฑะต. (ะะะะะะะะขะฌ ะ)
rus_verbs:ะพัะฒะตะดะพะผะธัััั{}, // ะพัะธัะตั ะพัะฒะตะดะพะผะธะปัั ะพ ัะตะปะธ ะฒะธะทะธัะฐ
rus_verbs:ะพะฑััะฒะธัั{}, // ะ ะณะฐะทะตัะต ะพะฑััะฒะธะปะธ ะพ ะบะพะฝะบัััะต. (ะพะฑััะฒะธัั ะพ)
rus_verbs:ะะ ะะะกะขะะฏะขะฌ{}, // ะพ ัะตะผ ะฟัะตะดััะพะธั ัะฐะทะณะพะฒะพั? (ะะ ะะะกะขะะฏะขะฌ ะ)
rus_verbs:ะพะฑััะฒะปััั{}, // ะพะฑััะฒะปััั ะพ ะฒัะตะพะฑัะตะน ะทะฐะฑะฐััะพะฒะบะต (ะพะฑััะฒะปััั ะพ)
rus_verbs:ะทะฐะนัะธ{}, // ะ ะฐะทะณะพะฒะพั ะทะฐััะป ะพ ะฟะพะปะธัะธะบะต.
rus_verbs:ะฟะพัะฐััะบะฐะทะฐัั{}, // ะฟะพัะฐััะบะฐะทะฐัั ะพ ัะฒะพะธั
ะฟััะตัะตััะฒะธัั
ะธะฝัะธะฝะธัะธะฒ:ัะฟะตัั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะฟะตัั{ ะฒะธะด:ัะพะฒะตัั }, // ัะฟะตัั ะพ ะฝะตัะฐะทะดะตะปะตะฝะฝะพะน ะปัะฑะฒะธ
ะดะตะตะฟัะธัะฐััะธะต:ัะฟะตะฒ{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฟะตะฒัะธะน{ ะฒะธะด:ัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฟะตััะน{},
rus_verbs:ะฝะฐะฟะตัั{},
rus_verbs:ัะฐะทะณะพะฒะฐัะธะฒะฐัั{}, // ัะฐะทะณะพะฒะฐัะธะฒะฐัั ั ะดััะณะพะผ ะพ ะถะธะทะฝะธ
rus_verbs:ัะฐัััะถะดะฐัั{}, // ัะฐัััะถะดะฐัั ะพะฑ ะฐะฑัััะฐะบัะฝัั
ะธะดะตัั
//rus_verbs:ะทะฐะฑะพัะธัััั{}, // ะทะฐะฑะพัะธัััั ะพ ะฟัะตััะฐัะตะปัั
ัะพะดะธัะตะปัั
rus_verbs:ัะฐะทะดัะผัะฒะฐัั{}, // ัะฐะทะดัะผัะฒะฐัั ะพ ะฝะพะฒะพะน ัะฐะฑะพัะต
rus_verbs:ะดะพะณะพะฒะฐัะธะฒะฐัััั{}, // ะดะพะณะพะฒะฐัะธะฒะฐัััั ะพ ััะผะผะต ะบะพะผะฟะตะฝัะฐัะธะธ
rus_verbs:ะผะพะปะธัั{}, // ะผะพะปะธัั ะพ ะฟะพัะฐะดะต
rus_verbs:ะพัะทัะฒะฐัััั{}, // ะพัะทัะฒะฐัััั ะพ ะบะฝะธะณะต
rus_verbs:ะฟะพะดัะผัะฒะฐัั{}, // ะฟะพะดัะผัะฒะฐัั ะพ ะฝะพะฒะพะผ ะฟะพะดั
ะพะดะต
rus_verbs:ะฟะพะณะพะฒะฐัะธะฒะฐัั{}, // ะฟะพะณะพะฒะฐัะธะฒะฐัั ะพ ะทะฐะณะฐะดะพัะฝะพะผ ะทะฒะตัะต
rus_verbs:ะพะฑะผะพะปะฒะธัััั{}, // ะพะฑะผะพะปะฒะธัััั ะพ ะฟัะพะบะปััะธะธ
rus_verbs:ััะปะพะฒะธัััั{}, // ััะปะพะฒะธัััั ะพ ะฟะพะดะดะตัะถะบะต
rus_verbs:ะฟัะธะทะฐะดัะผะฐัััั{}, // ะฟัะธะทะฐะดัะผะฐัััั ะพ ะฟะพัะปะตะดััะฒะธัั
rus_verbs:ะธะทะฒะตััะธัั{}, // ะธะทะฒะตััะธัั ะพ ะฟะพัััะฟะปะตะฝะธะธ
rus_verbs:ะพััะฐะฟะพััะพะฒะฐัั{}, // ะพััะฐะฟะพััะพะฒะฐัั ะพะฑ ััะฟะตั
ะฐั
rus_verbs:ะฝะฐะฟะตะฒะฐัั{}, // ะฝะฐะฟะตะฒะฐัั ะพ ะปัะฑะฒะธ
rus_verbs:ะฟะพะผััะปััั{}, // ะฟะพะผััะปััั ะพ ะฝะพะฒะพะผ ะดะตะปะต
rus_verbs:ะฟะตัะตะณะพะฒะพัะธัั{}, // ะฟะตัะตะณะพะฒะพัะธัั ะพ ะฟัะฐะฒะธะปะฐั
rus_verbs:ะฟะพะฒะตััะฒะพะฒะฐัั{}, // ะฟะพะฒะตััะฒะพะฒะฐัั ะพ ัะพะฑััะธัั
rus_verbs:ัะปัั
ะธะฒะฐัั{}, // ัะปัั
ะธะฒะฐัั ะพ ััะดะธัะต
rus_verbs:ะฟะพัะพะปะบะพะฒะฐัั{}, // ะฟะพัะพะปะบะพะฒะฐัั ะพ ะฟะปะฐะฝะฐั
rus_verbs:ะฟัะพะณะพะฒะพัะธัััั{}, // ะฟัะพะณะพะฒะพัะธัััั ะพ ะฟะปะฐะฝะฐั
rus_verbs:ัะผะพะปัะฐัั{}, // ัะผะพะปัะฐัั ะพ ัััะฐัะฐั
rus_verbs:ั
ะปะพะฟะพัะฐัั{}, // ั
ะปะพะฟะพัะฐัั ะพ ะฟัะตะผะธะธ
rus_verbs:ัะฒะตะดะพะผะธัั{}, // ัะฒะตะดะพะผะธัั ะพ ะฟะพัััะฟะปะตะฝะธะธ
rus_verbs:ะณะพัะตะฒะฐัั{}, // ะณะพัะตะฒะฐัั ะพ ะฟะพัะตัะต
rus_verbs:ะทะฐะฟะฐะผััะพะฒะฐัั{}, // ะทะฐะฟะฐะผััะพะฒะฐัั ะพ ะฒะฐะถะฝะพะผ ะผะตัะพะฟัะธััะธะธ
rus_verbs:ะทะฐะธะบะฝััััั{}, // ะทะฐะธะบะฝััััั ะพ ะฟัะธะฑะฐะฒะบะต
rus_verbs:ะธะฝัะพัะผะธัะพะฒะฐัั{}, // ะธะฝัะพัะผะธัะพะฒะฐัั ะพ ัะพะฑััะธัั
rus_verbs:ะฟัะพะฑะพะปัะฐัััั{}, // ะฟัะพะฑะพะปัะฐัััั ะพ ะบะปะฐะดะต
rus_verbs:ะฟะพัะฐะทะผััะปะธัั{}, // ะฟะพัะฐะทะผััะปะธัั ะพ ััะดัะฑะต
rus_verbs:ะทะฐะธะบะฐัััั{}, // ะทะฐะธะบะฐัััั ะพ ะดะตะฝัะณะฐั
rus_verbs:ะพะฟะพะฒะตััะธัั{}, // ะพะฟะพะฒะตััะธัั ะพะฑ ะพัะบะฐะทะต
rus_verbs:ะฟะตัััั{}, // ะฟะตัััั ะพ ะฒัะตะพะฑัะตะผ ะฑะปะฐะณะต
rus_verbs:ัะฐะทะณะปะฐะณะพะปัััะฒะพะฒะฐัั{}, // ัะฐะทะณะปะฐะณะพะปัััะฒะพะฒะฐัั ะพ ะฟัะฐะฒะฐั
rus_verbs:ัะฐะทะผะตััะฐัััั{}, // ัะฐะทะผะตััะฐัััั ะพ ะฑัะดััะตะผ
rus_verbs:ะปะตะฟะตัะฐัั{}, // ะปะตะฟะตัะฐัั ะพ ะฝะตะฒะธะฝะพะฒะฝะพััะธ
rus_verbs:ะณัะตะทะธัั{}, // ะณัะตะทะธัั ะพ ะฑะพะปััะพะน ะธ ัะธััะพะน ะปัะฑะฒะธ
rus_verbs:ะทะฐะปะตะฟะตัะฐัั{}, // ะทะฐะปะตะฟะตัะฐัั ะพ ัะพะบัะพะฒะธัะฐั
rus_verbs:ะฟัะพะฝัั
ะฐัั{}, // ะฟัะพะฝัั
ะฐัั ะพ ะฑะตัะฟะปะฐัะฝะพะน ะพะดะตะถะดะต
rus_verbs:ะฟัะพัััะฑะธัั{}, // ะฟัะพัััะฑะธัั ะพ ะฟะพะฑะตะดะต
rus_verbs:ะธะทะฒะตัะฐัั{}, // ะธะทะฒะตัะฐัั ะพ ะฟะพัััะฟะปะตะฝะธะธ
rus_verbs:ัััะฑะธัั{}, // ัััะฑะธัั ะพ ะฟะพะธะผะบะต ัะฐะทะฑะพะนะฝะธะบะพะฒ
rus_verbs:ะพัะฒะตะดะพะผะปััััั{}, // ะพัะฒะตะดะพะผะปััััั ะพ ััะดัะฑะต
rus_verbs:ะฟะพัะฐะทะผััะปััั{}, // ะฟะพัะฐะทะผััะปััั ะพ ะฝะตะธะทะฑะตะถะฝะพะผ
rus_verbs:ัะปะฐะณะฐัั{}, // ัะปะฐะณะฐัั ะพ ะฟะพะดะฒะธะณะฐั
ะฒะธะบะธะฝะณะพะฒ
rus_verbs:ั
ะพะดะฐัะฐะนััะฒะพะฒะฐัั{}, // ั
ะพะดะฐัะฐะนััะฒะพะฒะฐัั ะพ ะฒัะดะตะปะตะฝะธะธ ะผะฐัะตัะธะฐะปัะฝะพะน ะฟะพะผะพัะธ
rus_verbs:ะฟะพะฑะตัะฟะพะบะพะธัััั{}, // ะฟะพะฑะตัะฟะพะบะพะธัััั ะพ ะฟัะฐะฒะธะปัะฝะพะผ ััะธะผัะปะธัะพะฒะฐะฝะธะธ
rus_verbs:ะทะฐะบะธะดัะฒะฐัั{}, // ะทะฐะบะธะดัะฒะฐัั ัะพะพะฑัะตะฝะธัะผะธ ะพะฑ ะพัะธะฑะบะฐั
rus_verbs:ะฑะฐะทะฐัะธัั{}, // ะฟะฐัะฐะฝั ะฑะฐะทะฐัะธะปะธ ะพ ัะตะปะบะฐั
rus_verbs:ะฑะฐะปะฐะณััะธัั{}, // ะผัะถะธะบะธ ะฑะฐะปะฐะณััะธะปะธ ะพ ะฝะพะฒะพะผ ะฟัะตะดัะตะดะฐัะตะปะต
rus_verbs:ะฑะฐะปะฐะบะฐัั{}, // ะผัะถะธะบะธ ะฑะฐะปะฐะบะฐะปะธ ะพ ะฝะพะฒะพะผ ะฟัะตะดัะตะดะฐัะตะปะต
rus_verbs:ะฑะตัะฟะพะบะพะธัััั{}, // ะะฝะฐ ะฑะตัะฟะพะบะพะธััั ะพ ะดะตััั
rus_verbs:ัะฐััะบะฐะทะฐัั{}, // ะัะผะธั ัะฐััะบะฐะทะฐะป ะพ ะบัะธะผะธะฝะฐะปะต ะฒ ะะพัะบะฒะต
rus_verbs:ะฒะพะทะผะตััะฐัั{}, // ะฒะพะทะผะตััะฐัั ะพ ััะฐััะปะธะฒะพะผ ะผะธัะต
rus_verbs:ะฒะพะฟะธัั{}, // ะัะพ-ัะพ ะฒะพะฟะธะป ะพ ะฝะตัะฟัะฐะฒะตะดะปะธะฒะพััะธ
rus_verbs:ัะบะฐะทะฐัั{}, // ัะบะฐะทะฐัั ััะพ-ัะพ ะฝะพะฒะพะต ะพ ะบะพะผ-ัะพ
rus_verbs:ะทะฝะฐัั{}, // ะทะฝะฐัั ะพ ะบะพะผ-ัะพ ััะพ-ัะพ ะฟะธะบะฐะฝัะฝะพะต
rus_verbs:ะฟะพะดัะผะฐัั{}, // ะฟะพะดัะผะฐัั ะพ ััะผ-ัะพ
rus_verbs:ะดัะผะฐัั{}, // ะดัะผะฐัั ะพ ััะผ-ัะพ
rus_verbs:ัะทะฝะฐัั{}, // ัะทะฝะฐัั ะพ ะฟัะพะธััะตััะฒะธะธ
rus_verbs:ะฟะพะผะฝะธัั{}, // ะฟะพะผะฝะธัั ะพ ะทะฐะดะฐะฝะธะธ
rus_verbs:ะฟัะพัะธัั{}, // ะฟัะพัะธัั ะพ ะบะพะดะต ะดะพัััะฟะฐ
rus_verbs:ะทะฐะฑััั{}, // ะทะฐะฑััั ะพ ัะฒะพะธั
ะพะฑัะทะฐะฝะฝะพัััั
rus_verbs:ัะพะพะฑัะธัั{}, // ัะพะพะฑัะธัั ะพ ะทะฐะปะพะถะตะฝะฝะพะน ะผะธะฝะต
rus_verbs:ะทะฐัะฒะธัั{}, // ะทะฐัะฒะธัั ะพ ะฟัะพะฟะฐะถะต
rus_verbs:ะทะฐะดัะผะฐัััั{}, // ะทะฐะดัะผะฐัััั ะพ ัะผะตััะธ
rus_verbs:ัะฟัะฐัะธะฒะฐัั{}, // ัะฟัะฐัะธะฒะฐัั ะพ ะฟะพัััะฟะปะตะฝะธะธ ัะพะฒะฐัะฐ
rus_verbs:ะดะพะณะฐะดะฐัััั{}, // ะดะพะณะฐะดะฐัััั ะพ ะฟัะธัะธะฝะฐั
rus_verbs:ะดะพะณะพะฒะพัะธัััั{}, // ะดะพะณะพะฒะพัะธัััั ะพ ัะพะฑะตัะตะดะพะฒะฐะฝะธะธ
rus_verbs:ะผะตััะฐัั{}, // ะผะตััะฐัั ะพ ััะตะฝะต
rus_verbs:ะฟะพะณะพะฒะพัะธัั{}, // ะฟะพะณะพะฒะพัะธัั ะพ ะฝะฐะฑะพะปะตะฒัะตะผ
rus_verbs:ัะฐะทะผััะปััั{}, // ัะฐะทะผััะปััั ะพ ะฝะฐัััะฝะพะผ
rus_verbs:ะฝะฐะฟะพะผะธะฝะฐัั{}, // ะฝะฐะฟะพะผะธะฝะฐัั ะพ ัะตะฑะต
rus_verbs:ะฟะพะถะฐะปะตัั{}, // ะฟะพะถะฐะปะตัั ะพ ัะพะดะตัะฝะฝะพะผ
rus_verbs:ะฝััั{}, // ะฝััั ะพ ะฟัะธะฑะฐะฒะบะต
rus_verbs:ัะพะพะฑัะฐัั{}, // ัะพะพะฑัะฐัั ะพ ะฟะพะฑะตะดะต
rus_verbs:ะดะพะณะฐะดัะฒะฐัััั{}, // ะดะพะณะฐะดัะฒะฐัััั ะพ ะฟะตัะฒะพะฟัะธัะธะฝะต
rus_verbs:ะฟะพะฒะตะดะฐัั{}, // ะฟะพะฒะตะดะฐัั ะพ ัะฐะนะฝะฐั
rus_verbs:ัะผะพะปััั{}, // ัะผะพะปััั ะพ ะฟะพัะฐะดะต
rus_verbs:ัะพะถะฐะปะตัั{}, // ัะพะถะฐะปะตัั ะพ ัะปััะธะฒัะตะผัั
rus_verbs:ะถะฐะปะตัั{}, // ะถะฐะปะตัั ะพ ัะปััะธะฒัะตะผัั
rus_verbs:ะทะฐะฑัะฒะฐัั{}, // ะทะฐะฑัะฒะฐัั ะพ ัะปััะธะฒัะตะผัั
rus_verbs:ัะฟะพะผะธะฝะฐัั{}, // ัะฟะพะผะธะฝะฐัั ะพ ะฟัะตะดะบะฐั
rus_verbs:ะฟะพะทะฐะฑััั{}, // ะฟะพะทะฐะฑััั ะพ ัะฒะพะตะผ ะพะฑะตัะฐะฝะธะธ
rus_verbs:ะทะฐะฟะตัั{}, // ะทะฐะฟะตัั ะพ ะปัะฑะฒะธ
rus_verbs:ัะบะพัะฑะตัั{}, // ัะบะพัะฑะตัั ะพ ััะพะฟัะตะผ
rus_verbs:ะทะฐะดัะผัะฒะฐัััั{}, // ะทะฐะดัะผัะฒะฐัััั ะพ ัะผะตะฝะต ัะฐะฑะพัั
rus_verbs:ะฟะพะทะฐะฑะพัะธัััั{}, // ะฟะพะทะฐะฑะพัะธัััั ะพ ะฟัะตััะฐัะตะปัั
ัะพะดะธัะตะปัั
rus_verbs:ะดะพะบะปะฐะดัะฒะฐัั{}, // ะดะพะบะปะฐะดัะฒะฐัั ะพ ะฟะปะฐะฝะฐั
ัััะพะธัะตะปัััะฒะฐ ัะตะปะปัะปะพะทะฝะพ-ะฑัะผะฐะถะฝะพะณะพ ะบะพะผะฑะธะฝะฐัะฐ
rus_verbs:ะฟะพะฟัะพัะธัั{}, // ะฟะพะฟัะพัะธัั ะพ ะทะฐะผะตะฝะต
rus_verbs:ะฟัะตะดัะฟัะตะดะธัั{}, // ะฟัะตะดัะฟัะตะดะธัั ะพ ะทะฐะผะตะฝะต
rus_verbs:ะฟัะตะดัะฟัะตะถะดะฐัั{}, // ะฟัะตะดัะฟัะตะถะดะฐัั ะพ ะทะฐะผะตะฝะต
rus_verbs:ัะฒะตัะดะธัั{}, // ัะฒะตัะดะธัั ะพ ะทะฐะผะตะฝะต
rus_verbs:ะทะฐัะฒะปััั{}, // ะทะฐัะฒะปััั ะพ ะฟะพะดะปะพะณะต
rus_verbs:ะฟะตัั{}, // ะฟะตะฒะธัะฐ, ะฟะพััะฐั ะพ ะปะตัะต
rus_verbs:ะฟัะพะธะฝัะพัะผะธัะพะฒะฐัั{}, // ะฟัะพะธะฝัะพัะผะธัะพะฒะฐัั ะพ ะฟะตัะตะณะพะฒะพัะฐั
rus_verbs:ะฟะพัะฐััะบะฐะทัะฒะฐัั{}, // ะฟะพัะฐััะบะฐะทัะฒะฐัั ะพ ัะพะฑััะธัั
rus_verbs:ะฟะพัะปััะฐัั{}, // ะฟะพัะปััะฐัั ะพ ะฝะพะฒะธะฝะบะฐั
rus_verbs:ะทะฐะณะพะฒะพัะธัั{}, // ะทะฐะณะพะฒะพัะธัั ะพ ะฟะปะฐัะต
rus_verbs:ะพัะพะทะฒะฐัััั{}, // ะะฝ ะพัะพะทะฒะฐะปัั ะพ ะบะฝะธะณะต ั ะฑะพะปััะพะน ะฟะพั
ะฒะฐะปะพะน.
rus_verbs:ะพััะฐะฒะธัั{}, // ะะฝ ะพััะฐะฒะธะป ะพ ัะตะฑะต ะฟะตัะฐะปัะฝัั ะฟะฐะผััั.
rus_verbs:ัะฒะธะดะตัะตะปัััะฒะพะฒะฐัั{}, // ัััะฐัะฝะพ ะธัั
ัะดะฐะฒัะตะต ัะตะปะพ ัะฒะธะดะตัะตะปัััะฒะพะฒะฐะปะพ ะพ ะดะพะปะณะธั
ะปะธัะตะฝะธัั
rus_verbs:ัะฟะพัะธัั{}, // ะพะฝะธ ัะฟะพัะธะปะธ ะพ ะทะฐะบะพะฝะต
ะณะปะฐะณะพะป:ะฝะฐะฟะธัะฐัั{ aux stress="ะฝะฐะฟะธั^ะฐัั" }, ะธะฝัะธะฝะธัะธะฒ:ะฝะฐะฟะธัะฐัั{ aux stress="ะฝะฐะฟะธั^ะฐัั" }, // ะะฝ ะฝะฐะฟะธัะฐะป ะพ ัะพะผ, ััะพ ะฒะธะดะตะป ะฒะพ ะฒัะตะผั ะฟััะตัะตััะฒะธั.
ะณะปะฐะณะพะป:ะฟะธัะฐัั{ aux stress="ะฟะธั^ะฐัั" }, ะธะฝัะธะฝะธัะธะฒ:ะฟะธัะฐัั{ aux stress="ะฟะธั^ะฐัั" }, // ะะฝ ะฟะธัะฐะป ะพ ัะพะผ, ััะพ ะฒะธะดะตะป ะฒะพ ะฒัะตะผั ะฟััะตัะตััะฒะธั.
rus_verbs:ะฟัะพัะธัะฐัั{}, // ะฏ ะฟัะพัะธัะฐะป ะพ ัะตะฑะต
rus_verbs:ััะปััะฐัั{}, // ะฏ ััะปััะฐะป ะพ ะฝะตะผ
rus_verbs:ะฟะพะผะตััะฐัั{}, // ะะตะฒะพัะบะธ ะฟะพะผะตััะฐะปะธ ะพ ะฟัะธะฝัะต
rus_verbs:ัะปััะฐัั{}, // ะะฐะปััะธะบ ัะปััะฐะป ะพ ะฟัะธะฒะตะดะตะฝะธัั
rus_verbs:ะฒัะฟะพะผะฝะธัั{}, // ะะตะฒะพัะบะธ ะฒัะฟะพะผะฝะธะปะธ ะพ ะทะฐะฒััะฐะบะต
rus_verbs:ะณััััะธัั{}, // ะฏ ะณัััั ะพ ัะตะฑะต
rus_verbs:ะพัะฒะตะดะพะผะธัั{}, // ะพ ะฟะพัะปะตะดะฝะธั
ะดะพััะธะถะตะฝะธัั
ะฝะฐัะบะธ
rus_verbs:ัะฐััะบะฐะทัะฒะฐัั{}, // ะะฝัะพะฝะธะพ ัะฐััะบะฐะทัะฒะฐะตั ะพ ัะฐะฑะพัะต
rus_verbs:ะณะพะฒะพัะธัั{}, // ะณะพะฒะพัะธะผ ะพ ััะตั
ะฑะพะปััะธั
ะฟัะฐั
rus_verbs:ะธะดัะธ{} // ะะพะฟัะพั ะธะดัั ะพ ะฒะพะนะฝะต.
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะ_ะฟัะตะดะป ะฟัะตะดะปะพะณ:ะพ{} *:*{ ะฟะฐะดะตะถ:ะฟัะตะดะป } }
then return true
}
// ะั ะฟะพะดะตะปะธะปะธัั ะฒะฟะตัะฐัะปะตะฝะธัะผะธ ะพ ะฒัััะฐะฒะบะต.
// ^^^^^^^^^^ ^^^^^^^^^^
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะพ{} *:*{ ะฟะฐะดะตะถ:ะฟัะตะดะป } }
then return false,-3
}
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะพ{} *:*{} }
then return false,-5
}
#endregion ะัะตะดะปะพะณ_ะ
#region ะัะตะดะปะพะณ_ะะ
// ------------------- ะก ะะ ะะะะะะะ 'ะะ' ----------------------
// ะดะปั ััะธั
ะณะปะฐะณะพะปะพะฒ - ะทะฐะฟัะตัะฐะตะผ ัะฒัะทัะฒะฐะฝะธะต ั ะะ+ะดะฐั.ะฟ.
wordentry_set ะะปะฐะณ_ะะ_ะะฐั_ะะฐะฟั=
{
rus_verbs:ะฟัะตะดะฟัะธะฝััั{}, // ะฟัะตะดะฟัะธะฝััั ัะฐะณะธ ะฟะพ ััะธะผัะปะธัะพะฒะฐะฝะธั ะฟัะพะดะฐะถ
rus_verbs:ัะฒะปะตัั{}, // ัะฒะปะตัั ะฒ ะฟัะพะณัะปะบั ะฟะพ ะฟะฐัะบั
rus_verbs:ะทะฐะบะพะฝัะธัั{},
rus_verbs:ะผะพัั{},
rus_verbs:ั
ะพัะตัั{}
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะปะฐะณ_ะะ_ะะฐั_ะะฐะฟั ะฟัะตะดะปะพะณ:ะฟะพ{} *:*{ ะฟะฐะดะตะถ:ะดะฐั } }
then return false,-10
}
// ะะพ ัะผะพะปัะฐะฝะธั ัะฐะทัะตัะฐะตะผ ัะฒัะทัะฒะฐะฝะธะต ะฒ ะฟะฐััะตัะฝะฐั
ัะธะฟะฐ
// ะฏ ะธะดั ะฟะพ ัะพััะต
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฟะพ{} *:*{ ะฟะฐะดะตะถ:ะดะฐั } }
then return true
}
wordentry_set ะะปะฐะณ_ะะ_ะะธะฝ=
{
rus_verbs:ะะะะขะ{}, // ะปะตะทะฒะธะต ะฒะพัะปะพ ะฟะพ ััะบะพััั (ะะะะขะ)
rus_verbs:ะธะผะตัั{}, // ะฒัะต ะผะตัััั ะธะผะตะปะธ ะฟะพ ััะธะดัะฐัั ะดะฝะตะน. (ะะะะขะฌ ะะ)
rus_verbs:ะผะฐัะตัะธะฐะปะธะทะพะฒะฐัััั{}, // ะผะฐัะตัะธะฐะปะธะทะพะฒะฐัััั ะฟะพ ะดััะณัั ััะพัะพะฝั ะฑะฐััะตัะฐ
rus_verbs:ะทะฐัะฐะดะธัั{}, // ะทะฐัะฐะดะธัั ะฟะพ ััะบะพััะบั
rus_verbs:ัะฒัะทะฝััั{} // ัะฒัะทะฝััั ะฟะพ ะบะพะปะตะฝะพ
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะปะฐะณ_ะะ_ะะธะฝ ะฟัะตะดะปะพะณ:ะฟะพ{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return true
}
// ะดะปั ะพััะฐะปัะฝัั
ะฟะฐะดะตะถะตะน ะทะฐะฟัะตัะฐะตะผ.
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะฟะพ{} *:*{ ะฟะฐะดะตะถ:ะฒะธะฝ } }
then return false,-5
}
#endregion ะัะตะดะปะพะณ_ะะ
#region ะัะตะดะปะพะณ_ะ
// ------------------- ะก ะะ ะะะะะะะ 'ะ' ----------------------
wordentry_set ะะป_ะ_ะะฐั={
rus_verbs:ะทะฐัะฒะธัััั{}, // ะกัะฐะทั ะถะต ะฟะพัะปะต ะพะฑะตะดะฐ ะบ ะฝะฐะผ ะทะฐัะฒะธะปะฐัั ะฎะปะธั ะะธั
ะฐะนะปะพะฒะฝะฐ.
rus_verbs:ะฟัะธััะฐะฒะปััั{} , // ะัะธััะฐะฒะปัะตั ะดัะปะพ ะฟะธััะพะปะตัะฐ ะบ ะฒะธัะบั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะะะ ะะะะะะซะ{}, // ะฑะพะปััะธะฝััะฒะพ ะบะพะผะฟัััะตัะพะฒ ะธะท ััะพะน ะฟะฐััะธะธ ะพะบะฐะทะฐะปะธัั ะฝะตะฟัะธะณะพะดะฝัะผะธ ะบ ัะบัะฟะปัะฐัะฐัะธะธ (ะะะะ ะะะะะะซะ)
rus_verbs:ะกะะะะะขะฌะกะฏ{}, // ะะฝะธ ัััะปะธ ะฒะพะดั ะธ ัะฑะตะณะฐะปะธัั ะบ ะฝะตะน ะพัะพะฒััะดั. (ะกะะะะะขะฌะกะฏ)
rus_verbs:ะกะะะะะขะฌะกะฏ{}, // ะ ะฑะตัะพะฝะฝะพะน ัะบะฐะผัะต ะฝะฐัะฐะปะธ ัะฑะตะณะฐัััั ะปัะดะธ. (ะกะะะะะขะฌะกะฏ/ะกะะะะะขะฌะกะฏ)
rus_verbs:ะะ ะะขะะ ะะขะฌะกะฏ{}, // ะะตะฝะตะต ััะพะนะบะธั
ะฒะพะดะธัะตะปะตะน ะฑัะบะฒะฐะปัะฝะพ ัะผะตัะฐะปะพ ะฝะฐ ะดััะณัั ะฟะพะปะพัั, ะธ ะพะฝะธ ะฒะฟัะธััะบ ะฟัะธัะธัะฐะปะธัั ะบ ะดััะณะธะผ ะผะฐัะธะฝะฐะผ. (ะะ ะะขะะ ะะขะฌะกะฏ)
rus_verbs:ะ ะฃะฅะะฃะขะฌ{}, // ะฐ ะฟะพัะพะผ ัั ะฑะตะท ััะฒััะฒ ััั
ะฝัะป ะบ ะผะพะธะผ ะฝะพะณะฐะผ (ะ ะฃะฅะะฃะขะฌ)
rus_verbs:ะะะ ะะะะกะขะ{}, // ะะฝะธ ะฟะตัะตะฝะตัะปะธ ะผััะพ ะบ ััััั ะธ ะฟะพะดะถะฐัะธะปะธ ะตะณะพ ะฝะฐ ะบะพัััะต. (ะะะ ะะะะกะขะ)
rus_verbs:ะะะะะกะขะ{}, // ะบะฐะบ ะฟััั ะผะพะน ะทะฐะฒะตะป ะผะตะฝั ะบ ะฝะตะผั? (ะะะะะกะขะ)
rus_verbs:ะะะะ ะฏะะฃะขะฌ{}, // ะคะะ ะฝะฐะณััะฝัะปะพ ั ะพะฑััะบะพะผ ะบ ัะตัััะต ะฑะพััะพะฝัะบะธั
ัะตััะพัะธััะพะฒ (ะะะะ ะฏะะฃะขะฌ)
rus_verbs:ะะ ะะกะะะะฏะขะฌะกะฏ{}, // ะ ะฐะฑั ะปะพะถะธะปะธัั ะฝะฐ ะฟะพะป, ะฟัะธัะปะพะฝัะปะธัั ะบ ััะตะฝะต ะธ ัะฟะฐะปะธ. (ะะ ะะกะะะะฏะขะฌะกะฏ,ะะ ะะะะ ะะะะะะะขะฌะกะฏ,ะะ ะะะะ ะะะะขะฌะกะฏ)
rus_verbs:ะะ ะะะะ ะะะะะะะขะฌะกะฏ{}, //
rus_verbs:ะะ ะะะะ ะะะะขะฌะกะฏ{}, //
rus_verbs:ะกะะะะะะ ะะะะขะฌ{}, // ะัะบะพัะต ะพะฝะฐ ะพััะฐะฝะพะฒะธะปะฐ ัะฒะพะต ะฟะฐะดะตะฝะธะต ะธ ัะฟะปะฐะฝะธัะพะฒะฐะปะฐ ะบ ะฝะธะผ. (ะกะะะะะะ ะะะะขะฌ,ะกะะะะะ ะะะะขะฌ,ะ ะฃะฅะะฃะขะฌ)
rus_verbs:ะกะะะะะ ะะะะขะฌ{}, //
rus_verbs:ะะะะ ะะขะฌะกะฏ{}, // ะะพััะพะผั ะพะฝ ะทะฐะฑัะฐะปัั ะบะพ ะผะฝะต ะฒ ะบะฒะฐััะธัั ั ะธะผะตะฒัะธะผัั ั ะฝะตะณะพ ะฟะพะปัะผะตัััะตะผ. (ะะะะ ะะขะฌะกะฏ ะ, ะ, ะก)
rus_verbs:ะะ ะะขะฏะะะะะขะฌ{}, // ะะฝะพ ะฟัะพััะณะธะฒะฐะปะพ ัะฒะพะธ ะดะปะธะฝะฝัะต ััะบะธ ะบ ะผะพะปะพะดะพะผั ัะตะปะพะฒะตะบั, ััะพัะฒัะตะผั ะฝะฐ ะฟะปะพัะบะพะน ะฒะตััะธะฝะต ะฒะฐะปัะฝะฐ. (ะะ ะะขะฏะะะะะขะฌ/ะะ ะะขะฏะะฃะขะฌ/ะขะฏะะฃะขะฌ)
rus_verbs:ะะ ะะขะฏะะฃะขะฌ{}, //
rus_verbs:ะขะฏะะฃะขะฌ{}, //
rus_verbs:ะะะ ะะะะ ะะขะฌะกะฏ{}, // ะะต ะณัะฑั ะผะตะดะปะตะฝะฝะพ ะฟะตัะตะฑะธัะฐะปะธัั ะบ ะตะณะพ ัั
ั. (ะะะ ะะะะ ะะขะฌะกะฏ,ะะะ ะะะ ะะขะฌะกะฏ,ะะะ ะะะะะะ ะะะะขะฌะกะฏ,ะะะ ะะะะกะขะะขะฌะกะฏ,ะะะ ะะะะฉะะขะฌะกะฏ)
rus_verbs:ะะะ ะะะ ะะขะฌะกะฏ{}, // ,,,
rus_verbs:ะะะ ะะะะะะ ะะะะขะฌะกะฏ{}, //
rus_verbs:ะะะ ะะะะกะขะะขะฌะกะฏ{}, //
rus_verbs:ะะะ ะะะะฉะะขะฌะกะฏ{}, //
rus_verbs:ะขะ ะะะฃะขะฌะกะฏ{}, // ะะฝ ะพัะฒะตัะฝัะปัั ะพั ะฝะตะต ะธ ััะพะฝัะปัั ะบ ะฟะปัะถั. (ะขะ ะะะฃะขะฌะกะฏ)
rus_verbs:ะะ ะะกะขะะะะขะฌ{}, // ะะฝ ะฟะพะดะฝัะป ะพะดะฝั ะธะท ะฝะธั
ะธ ะฟัะธััะฐะฒะธะป ะฒะตัั
ะฝะธะน ะบะพะฝะตั ะบ ะบัะฐั ัะฐั
ัั ะฒ ะฟะพัะพะปะบะต.
rus_verbs:ะะ ะะะะขะฌะกะฏ{}, // ะัััะด ั ะฝะตะฒะตัะพััะฝัะผะธ ะฟัะธะบะปััะตะฝะธัะผะธ, ะฟััะฐะตััั ะฟัะพะฑะธัััั ะบ ัะฒะพะตะผั ะฟะพะปะบั, ะฟะพะฟะฐะดะฐะตั ะฒ ะฟะปะตะฝ ะธ ะดััะณะธะต ะฟะตัะตะดััะณะธ (ะะ ะะะะขะฌะกะฏ)
rus_verbs:ั
ะพัะตัั{},
rus_verbs:ะกะะะะะขะฌ{}, // ะกะดะตะปะฐะนัะต ะฒัั ะบ ะฟะพะฝะตะดะตะปัะฝะธะบั (ะกะะะะะขะฌ)
rus_verbs:ะะกะะซะขะซะะะขะฌ{}, // ะพะฝะฐ ะธัะฟัััะฒะฐะตั ะบะพ ะผะฝะต ัะพะปัะบะพ ะพัะฒัะฐัะตะฝะธะต (ะะกะะซะขะซะะะขะฌ)
rus_verbs:ะะะฏะะซะะะขะฌ{}, // ะญัะพ ะผะตะฝั ะฝะธ ะบ ัะตะผั ะฝะต ะพะฑัะทัะฒะฐะตั (ะะะฏะะซะะะขะฌ)
rus_verbs:ะะะ ะะะะะขะฌะกะฏ{}, // ะบะฐัะฐะฑะบะฐัััั ะฟะพ ะณะพัะต ะพั ะฟะพะดะฝะพะถะธั ะบ ะฒะตััะธะฝะต (ะะะ ะะะะะขะฌะกะฏ)
rus_verbs:ะกะขะะฏะขะฌ{}, // ะผัะถัะธะฝะฐ ััะพัะป ะบะพ ะผะฝะต ัะฟะธะฝะพะน (ะกะขะะฏะขะฌ)
rus_verbs:ะะะะะขะฌะกะฏ{}, // ะฝะฐะบะพะฝะตั ะปัะบ ะฟะพะดะฐะปัั ะบะพ ะผะฝะต (ะะะะะขะฌะกะฏ)
rus_verbs:ะะ ะะ ะะะะฏะขะฌ{}, // ะฃัะธะปะธั ะฝะตะปัะทั ะฟัะธัะฐะฒะฝััั ะบ ัะตะทัะปััะฐัั (ะะ ะะ ะะะะฏะขะฌ)
rus_verbs:ะะ ะะ ะะะะะะะขะฌ{}, // ะฃัะธะปะธั ะฝะตะปัะทั ะฟัะธัะฐะฒะฝะธะฒะฐัั ะบ ัะตะทัะปััะฐัั (ะะ ะะ ะะะะะะะขะฌ)
rus_verbs:ะะะะะะะะขะฌ{}, // ะััะธะฝ ะฒ ะัะบะพะฒะต ะฒะพะทะปะพะถะธะป ัะฒะตัั ะบ ะฟะฐะผััะฝะธะบั ะฒะพะธะฝะฐะผ-ะดะตัะฐะฝัะฝะธะบะฐะผ, ะฟะพะณะธะฑัะธะผ ะฒ ะงะตัะฝะต (ะะะะะะะะขะฌ)
rus_verbs:ะทะฐะฟัััะธัั{}, // ะะฝะดะธั ะทะฐะฟัััะธั ะบ ะะฐััั ัะฒะพะน ะบะพัะผะธัะตัะบะธะน ะฐะฟะฟะฐัะฐั ะฒ 2013 ะณ
rus_verbs:ะะ ะะกะขะซะะะะะขะฌะกะฏ{}, // ะ ะพะฑะพัะธะทะธัะพะฒะฐะฝะฝัะน ัะพััะธะนัะบะธะน ะณััะทะพะฒะพะน ะบะพัะผะธัะตัะบะธะน ะบะพัะฐะฑะปั ะฟัะธัััะบะพะฒะฐะปัั ะบ ะะะก (ะะ ะะกะขะซะะะะะขะฌะกะฏ)
rus_verbs:ะะ ะะะะะะขะฌะกะฏ{}, // ะ ัะตะปัะฑะธะฝัะบะพะผั ะผะตัะตะพัะธัั ะฟัะธะผะฐะทะฐะปะฐัั ัะฐะธะฝััะฒะตะฝะฝะฐั ัะปะธะทั (ะะ ะะะะะะขะฌะกะฏ)
rus_verbs:ะะะะ ะะกะะขะฌ{}, // ะะพะฟัะพัะธัะต ะะธะทั ะบ ัะตะปะตัะพะฝั (ะะะะ ะะกะะขะฌ ะ)
rus_verbs:ะะ ะะะฅะะขะฌ{}, // ะะพัะพะน ัะบะพะปัะฝัะต ะฐะฒัะพะฑััั ะฟัะพััะพ ะฝะต ะธะผะตัั ะฒะพะทะผะพะถะฝะพััะธ ะฟัะพะตั
ะฐัั ะบ ะฝะตะบะพัะพััะผ ะฝะฐัะตะปะตะฝะฝัะผ ะฟัะฝะบัะฐะผ ะธะท-ะทะฐ ะฑะตะทะดะพัะพะถัั (ะะ ะะะฅะะขะฌ ะ)
rus_verbs:ะะะะฆะะะะฏะขะฌะกะฏ{}, // ะะฐะณะพะฝั ั ะฟะฐััะฐะถะธัะฐะผะธ ะฟะพะดัะตะฟะปััััั ะบ ัะพััะฐะฒั (ะะะะฆะะะะฏะขะฌะกะฏ ะ)
rus_verbs:ะะ ะะะะะขะฌ{}, // ะัะตะทะธะดะตะฝั ะัะณะฐะฝะธััะฐะฝะฐ ะฟัะธะทะฒะฐะป ัะฐะปะธะฑะพะฒ ะบ ะฟััะผะพะผั ะดะธะฐะปะพะณั (ะะ ะะะะะขะฌ ะ)
rus_verbs:ะะ ะะะะ ะะะะขะฌะกะฏ{}, // ะัะปััะพะฒัะน ััะพะปะธัะฝัะน ะพัะตะปั ะฟัะตะพะฑัะฐะทะธะปัั ะบ ัะฑะธะปะตั (ะะ ะะะะ ะะะะขะฌะกะฏ ะ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะงะฃะะกะขะะะขะะะฌะะซะ{}, // ะฝะตะนัะพะฝั ะพะดะฝะพะณะพ ะบะพะผะฟะปะตะบัะฐ ััะฒััะฒะธัะตะปัะฝั ะบ ัะฐะทะฝัะผ ะฒะตัะตััะฒะฐะผ (ะงะฃะะกะขะะะขะะะฌะะซะ ะ)
ะฑะตะทะปะธั_ะณะปะฐะณะพะป:ะฝัะถะฝะพ{}, // ะฝะฐะผ ะฝัะถะฝะพ ะบ ะฒะพัะพัะฐะผ (ะะฃะะะ ะ)
rus_verbs:ะะ ะะกะะขะฌ{}, // ะพะณัะพะผะฝัะน ะบะปัะฒ ะฑัะพัะธะป ััะพ ะผััะพ ะบ ะผะพะธะผ ะฝะพะณะฐะผ (ะะ ะะกะะขะฌ ะ)
rus_verbs:ะะะะะะงะะขะฌ{}, // ะบ ะฟััะธ ัััะฐ ัะตั
ะฝะธะบะธ ะทะฐะบะพะฝัะธะปะธ (ะะะะะะงะะขะฌ ะ)
rus_verbs:ะะะกะขะ{}, // ะบ ะฑะตัะตะณั ะฝะฐั ะฝะตัะตั! (ะะะกะขะ ะ)
rus_verbs:ะะ ะะะะะะะขะฌะกะฏ{}, // ะฟะปะตะผะตะฝะฐ ะผะตะดะปะตะฝะฝะพ ะฟัะพะดะฒะธะณะฐะปะธัั ะบ ะฒะพััะพะบั (ะะ ะะะะะะะขะฌะกะฏ ะ)
rus_verbs:ะะะฃะกะะะขะฌะกะฏ{}, // ะดะตัะตะฒัั ะพะฟััะบะฐะปะธัั ะบ ัะฐะผะพะน ะฒะพะดะต (ะะะฃะกะะะขะฌะกะฏ ะ)
rus_verbs:ะกะขะะะะะขะฌ{}, // ะบ ัะพะผั ะฒัะตะผะตะฝะธ ััะตะผะฝะตะปะพ (ะกะขะะะะะะ ะ)
rus_verbs:ะะขะกะะะงะะขะฌ{}, // ะฟะพัะปะต ะพััะบะพัะธะป ะบ ะพะบะฝั (ะะขะกะะะงะะขะฌ ะ)
rus_verbs:ะะะ ะะะขะฌะกะฏ{}, // ะบ ัะพะปะฝัั ะดะตัะถะฐะปะธัั ัะฟะธะฝะฐะผะธ (ะะะ ะะะขะฌะกะฏ ะ)
rus_verbs:ะะะงะะฃะขะฌะกะฏ{}, // ัะพะปะฟะฐ ะบะฐัะฝัะปะฐัั ะบ ัััะฟะตะฝัะผ (ะะะงะะฃะขะฌะกะฏ ะ)
rus_verbs:ะะะะขะ{}, // ะะฝะดัะตะน ะฒะพัะตะป ะบ ัะตะฑะต (ะะะะขะ ะ)
rus_verbs:ะะซะะ ะะขะฌะกะฏ{}, // ะผั ะฒัะฑัะฐะปะธัั ะบ ะพะบะฝั (ะะซะะ ะะขะฌะกะฏ ะ)
rus_verbs:ะะ ะะะะกะขะ{}, // ะฟัะพะฒะตะป ะบ ััะตะฝะต ัะฟะฐะปัะฝะธ (ะะ ะะะะกะขะ ะ)
rus_verbs:ะะะ ะะฃะขะฌะกะฏ{}, // ะดะฐะฒะฐะน ะฒะตัะฝะตะผัั ะบ ะดะตะปั (ะะะ ะะฃะขะฌะกะฏ ะ)
rus_verbs:ะะะะะ ะะขะะขะฌะกะฏ{}, // ะกัะตะดะธ ะตะฒัะตะตะฒ, ะถะธะฒัะธั
ะฒ ะดะธะฐัะฟะพัะต, ะฒัะตะณะดะฐ ะฑัะปะพ ัะฐัะฟัะพัััะฐะฝะตะฝะพ ัะธะปัะฝะพะต ัััะตะผะปะตะฝะธะต ะฒะพะทะฒัะฐัะธัััั ะบ ะกะธะพะฝั (ะะะะะ ะะขะะขะฌะกะฏ ะ)
rus_verbs:ะะ ะะะะะะขะฌ{}, // ะะฐะดะฝัั ะฟะพะฒะตัั
ะฝะพััั ั
ััััะฐะปะธะบะฐ ะฟัะธะปะตะณะฐะตั ะบ ััะตะบะปะพะฒะธะดะฝะพะผั ัะตะปั (ะะ ะะะะะะขะฌ ะ)
rus_verbs:ะะะ ะะะะกะขะะกะฌ{}, // ะผััะปะตะฝะฝะพ ะะปัะฝะฐ ะฟะตัะตะฝะตัะปะฐัั ะบ ะทะฐะปะธะฒั (ะะะ ะะะะกะขะะกะฌ ะ)
rus_verbs:ะะ ะะะะะะขะฌะกะฏ{}, // ัะบะฒะพะทั ะฑะพะปะพัะพ ะบ ะฑะตัะตะณั ะฟัะพะฑะธะฒะฐะปัั ัััะตะน. (ะะ ะะะะะะขะฌะกะฏ ะ)
rus_verbs:ะะะ ะะะะกะขะ{}, // ะฝะตะพะฑั
ะพะดะธะผะพ ััะพัะฝะพ ะฟะตัะตะฒะตััะธ ััะฐะดะพ ะบ ะฒะพะดะต. (ะะะ ะะะะกะขะ ะ)
rus_verbs:ะะ ะะะะขะะขะฌ{}, // ะทะฐัะตะผ ัั ะฟัะธะปะตัะตะป ะบ ะฝะฐะผ? (ะะ ะะะะขะะขะฌ ะ)
rus_verbs:ะะะะะะะขะฌ{}, // ะดะพะฑะฐะฒะธัั ะปะธ ะตะต ะบ ะพััะฐะปัะฝัะผ? (ะะะะะะะขะฌ ะ)
rus_verbs:ะะ ะะะะขะะะะขะฌ{}, // ะะฐัะฒะตะน ะฟัะธะณะพัะพะฒะธะป ะปัะบ ะบ ะฑะพั. (ะะ ะะะะขะะะะขะฌ ะ)
rus_verbs:ะ ะะะะฃะขะฌ{}, // ัะตะปะพะฒะตะบ ัะฒะฐะฝัะป ะตะต ะบ ัะตะฑะต. (ะ ะะะะฃะขะฌ ะ)
rus_verbs:ะขะะฉะะขะฌ{}, // ะพะฝะธ ัะฐัะธะปะธ ะผะตะฝั ะบ ะดะฒะตัะธ. (ะขะะฉะะขะฌ ะ)
ะณะปะฐะณะพะป:ะฑััั{}, // ะบ ัะตะฑะต ะตััั ะฒะพะฟัะพัั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฐะฒะฝะพะดััะฝัะน{}, // ะะฝ ัะฐะฒะฝะพะดััะตะฝ ะบ ะผัะทัะบะต.
rus_verbs:ะะะะะะะะะขะฌ{}, // ัะบะฐะฝะดะฐะปัะฝะพ ะธะทะฒะตััะฝัะน ะฟะตะฒะตั ะฟะพะถะฐะปะพะฒะฐะป ะบ ะฝะฐะผ ะฝะฐ ะฟะตัะตะดะฐัั (ะะะะะะะะะขะฌ ะ)
rus_verbs:ะะะ ะะกะะกะขะฌ{}, // ะะปัะณะฐ ะฟะตัะตัะตะปะฐ ะบ ะะฝัะพะฝั (ะะะ ะะกะะกะขะฌ ะ)
ะธะฝัะธะฝะธัะธะฒ:ะกะะะะะขะฌ{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ะกะะะะะขะฌ{ ะฒะธะด:ัะพะฒะตัั }, // ัะฑะตะณะฐะน ะบ ะะพัะธัั (ะกะะะะะขะฌ ะ)
rus_verbs:ะะะ ะะฅะะะะขะฌ{}, // ะฟัะฐะฒะพ ั
ะพะดะฐ ะฟะตัะตั
ะพะดะธั ะบ ะะดะฐะผั (ะะะ ะะฅะะะะขะฌ ะ)
rus_verbs:ะฟัะธะถะฐัััั{}, // ะพะฝะฐ ะฟัะธะถะฐะปะฐัั ัะตะบะพะน ะบ ะตะณะพ ัะตะต. (ะฟัะธะถะฐัััั+ะบ)
rus_verbs:ะะะะกะะะงะะขะฌ{}, // ัะพะปะดะฐั ะฑััััะพ ะฟะพะดัะบะพัะธะป ะบะพ ะผะฝะต. (ะะะะกะะะงะะขะฌ ะ)
rus_verbs:ะะ ะะะ ะะขะฌะกะฏ{}, // ะฝัะถะฝะพ ะฟัะพะฑัะฐัััั ะบ ัะตะบะต. (ะะ ะะะ ะะขะฌะกะฏ ะ)
rus_verbs:ะะะขะะะะขะฌ{}, // ะฝะฐั ะณะพัะพะฒะธะปะธ ะบ ััะพะผั. (ะะะขะะะะขะฌ ะ)
rus_verbs:ะขะะงะฌ{}, // ัะตะบะฐ ัะตะบะปะฐ ะบ ะผะพัั. (ะขะะงะฌ ะ)
rus_verbs:ะะขะจะะขะะฃะขะฌะกะฏ{}, // ะตะฟะธัะบะพะฟ ะพััะฐัะฝัะปัั ะบ ััะตะฝะต. (ะะขะจะะขะะฃะขะฌะกะฏ ะ)
rus_verbs:ะะ ะะขะฌ{}, // ะฑัะฐะปะธ ะฑั ะบ ัะตะฑะต. (ะะ ะะขะฌ ะ)
rus_verbs:ะกะะะะฌะะะฃะขะฌ{}, // ะบะพะฒะตั ัะบะพะปัะทะฝัะป ะบ ะฟะตัะตัะต. (ะกะะะะฌะะะฃะขะฌ ะ)
rus_verbs:ะฟัะธัะพั
ะฝััั{}, // ะััะทั ะฟัะธัะพั
ะปะฐ ะบ ะพะดะตะถะดะต. (ะฟัะธัะพั
ะฝััั ะบ)
rus_verbs:ะฟัะพัะธัั{}, // ะะธัะตะบัะพั ะฟัะพัะธั ะฒะฐั ะบ ัะตะฑะต. (ะฟัะพัะธัั ะบ)
rus_verbs:ะฒัะทัะฒะฐัั{}, // ัะตั ะฒัะทัะฒะฐะป ะบ ัะตะฑะต. (ะฒัะทัะฒะฐัั ะบ)
rus_verbs:ะฟัะธัะตััั{}, // ััะฐัะธะบ ะฟัะธัะตะป ะบ ะพะณะฝั. (ะฟัะธัะตััั ะบ)
rus_verbs:ะะะะะะะะขะฌะกะฏ{}, // ะ ะธัะฐัะด ะฝะฐะบะปะพะฝะธะปัั ะบ ะฑัะฐัั. (ะะะะะะะะขะฌะกะฏ ะ)
rus_verbs:ะฒัะฑะธัะฐัััั{}, // ะฑัะดะตะผ ะฒัะฑะธัะฐัััั ะบ ะดะพัะพะณะต. (ะฒัะฑะธัะฐัััั ะบ)
rus_verbs:ะพัะฒะตัะฝััััั{}, // ะะธะบัะพั ะพัะฒะตัะฝัะปัั ะบ ััะตะฝะต. (ะพัะฒะตัะฝััััั ะบ)
rus_verbs:ะกะขะะฅะะฃะขะฌ{}, // ะพะณะพะฝั ััะธั
ะบ ะฟะพะปัะดะฝั. (ะกะขะะฅะะฃะขะฌ ะ)
rus_verbs:ะฃะะะกะขะฌ{}, // ะฝะพะถ ัะฟะฐะป ะบ ะฝะพะณะฐะผ. (ะฃะะะกะขะฌ ะ)
rus_verbs:ะกะะกะขะฌ{}, // ะผะพะปัะฐ ัะตะป ะบ ะพะณะฝั. (ะกะะกะขะฌ ะ)
rus_verbs:ะฅะะซะะฃะขะฌ{}, // ะฝะฐัะพะด ั
ะปัะฝัะป ะบ ััะตะฝะฐะผ. (ะฅะะซะะฃะขะฌ ะ)
rus_verbs:ะฟะพะบะฐัะธัััั{}, // ะพะฝะธ ัะตัะฝะพะน ะฒะพะปะฝะพะน ะฟะพะบะฐัะธะปะธัั ะบะพ ะผะฝะต. (ะฟะพะบะฐัะธัััั ะบ)
rus_verbs:ะะะ ะะขะะขะฌ{}, // ะพะฝะฐ ะพะฑัะฐัะธะปะฐ ะบ ะฝะตะผั ัะฒะพะต ะฑะปะตะดะฝะพะต ะปะธัะพ. (ะะะ ะะขะะขะฌ ะ)
rus_verbs:ะกะะะะะะขะฌ{}, // ะะถะพะฝ ัะปะตะณะบะฐ ัะบะปะพะฝะธะป ะณะพะปะพะฒั ะบ ะฟะปะตัั. (ะกะะะะะะขะฌ ะ)
rus_verbs:ะกะะะ ะะฃะขะฌ{}, // ะดะพัะพะถะบะฐ ัะตะทะบะพ ัะฒะตัะฝัะปะฐ ะบ ัะถะฝะพะน ััะตะฝะต. (ะกะะะ ะะฃะขะฌ ะ)
rus_verbs:ะะะะะ ะะฃะขะฌ{}, // ะะฝ ะทะฐะฒะตัะฝัะป ะบ ะฝะฐะผ ะฟะพ ะฟััะธ ะบ ะผะตััั ัะปัะถะฑั. (ะะะะะ ะะฃะขะฌ ะ)
rus_verbs:ะฟะพะดั
ะพะดะธัั{}, // ัะฒะตั ะฟะพะดั
ะพะดะธะป ะตะน ะบ ะปะธัั.
rus_verbs:ะะ ะะกะขะ{}, // ะ ะธัะฐัะด ะฟะพะบะพัะฝะพ ะฑัะตะป ะบ ะพััั. (ะะ ะะกะขะ ะ)
rus_verbs:ะะะะะกะขะฌ{}, // ั
ะพัะตัั ะฟะพะฟะฐััั ะบ ะฝะตะผั? (ะะะะะกะขะฌ ะ)
rus_verbs:ะะะะะฏะขะฌ{}, // ะะฐััะธะฝ ะฟะพะดะฝัะป ััะถัะต ะบ ะฟะปะตัั. (ะะะะะฏะขะฌ ะ)
rus_verbs:ะะะขะะ ะฏะขะฌ{}, // ะฟัะพััะพ ะฟะพัะตััะปะฐ ะบ ะฝะตะผั ะธะฝัะตัะตั. (ะะะขะะ ะฏะขะฌ ะ)
rus_verbs:ะ ะะะะะ ะะฃะขะฌะกะฏ{}, // ะพะฝะธ ััะฐะทั ัะฐะทะฒะตัะฝัะปะธัั ะบะพ ะผะฝะต. (ะ ะะะะะ ะะฃะขะฌะกะฏ ะ)
rus_verbs:ะะะะะ ะะฃะขะฌ{}, // ะผะฐะปััะธะบ ะฟะพะฒะตัะฝัะป ะบ ะฝะธะผ ะณะพะปะพะฒั. (ะะะะะ ะะฃะขะฌ ะ)
rus_verbs:ะฒัะทะฒะฐัั{}, // ะธะปะธ ะฒัะทะฒะฐัั ะบ ะถะธะทะฝะธ? (ะฒัะทะฒะฐัั ะบ)
rus_verbs:ะะซะฅะะะะขะฌ{}, // ะธั
ะทะตะผะปะธ ะฒัั
ะพะดัั ะบ ะผะพัั. (ะะซะฅะะะะขะฌ ะ)
rus_verbs:ะะฅะะขะฌ{}, // ะผั ะดะพะปะณะพ ะตั
ะฐะปะธ ะบ ะฒะฐะผ. (ะะฅะะขะฌ ะ)
rus_verbs:ะพะฟัััะธัััั{}, // ะะปะธัะฐ ะพะฟัััะธะปะฐัั ะบ ัะฐะผะพะผั ะดะฝั. (ะพะฟัััะธัััั ะบ)
rus_verbs:ะฟะพะดะฝััััั{}, // ะพะฝะธ ะผะพะปัะฐ ะฟะพะดะฝัะปะธัั ะบ ัะตะฑะต. (ะฟะพะดะฝััััั ะบ)
rus_verbs:ะะะะะฃะขะฌะกะฏ{}, // ัะพะปัััะบ ััะถะตะปะพ ะดะฒะธะฝัะปัั ะบ ะฝะธะผ. (ะะะะะฃะขะฌะกะฏ ะ)
rus_verbs:ะะะะฏะขะะขะฌะกะฏ{}, // ะฒะตะดัะผะฐะบ ะพััะพัะพะถะฝะพ ะฟะพะฟััะธะปัั ะบ ะปะพัะฐะดะธ. (ะะะะฏะขะะขะฌะกะฏ ะ)
rus_verbs:ะ ะะะฃะขะฌะกะฏ{}, // ะผััะตะปะพะฒ ัะธะฝัะปัั ะบ ัะตัะฝะพะน ััะตะฝะต. (ะ ะะะฃะขะฌะกะฏ ะ)
rus_verbs:ะขะะะะะฃะขะฌ{}, // ะบ ััะพะผั ัะพะปะบะฝัะป ะตะต ัั. (ะขะะะะะฃะขะฌ ะ)
rus_verbs:ะพัะฟััะณะฝััั{}, // ะะฐะดะธะผ ะฟะพัะฟะตัะฝะพ ะพัะฟััะณะฝัะป ะบ ะฑะพััั. (ะพัะฟััะณะฝััั ะบ)
rus_verbs:ะพััััะฟะธัั{}, // ะผั ะฟะพัะฟะตัะฝะพ ะพััััะฟะธะปะธ ะบ ััะตะฝะต. (ะพััััะฟะธัั ะบ)
rus_verbs:ะะะะ ะะขะฌ{}, // ะผั ะทะฐะฑัะฐะปะธ ะธั
ะบ ัะตะฑะต. (ะะะะ ะะขะฌ ะบ)
rus_verbs:ะะะฏะขะฌ{}, // ะฟะพัะพะผ ะฒะพะทัะผั ัะตะฑั ะบ ัะตะฑะต. (ะะะฏะขะฌ ะ)
rus_verbs:ะปะตะถะฐัั{}, // ะฝะฐั ะฟััั ะปะตะถะฐะป ะบ ะฝะธะผ. (ะปะตะถะฐัั ะบ)
rus_verbs:ะฟะพะฟะพะปะทัะธ{}, // ะตะต ััะบะฐ ะฟะพะฟะพะปะทะปะฐ ะบ ะพััะถะธั. (ะฟะพะฟะพะปะทัะธ ะบ)
rus_verbs:ััะตะฑะพะฒะฐัั{}, // ะฒะฐั ััะตะฑัะตั ะบ ัะตะฑะต ะธะผะฟะตัะฐัะพั. (ััะตะฑะพะฒะฐัั ะบ)
rus_verbs:ะฟะพะตั
ะฐัั{}, // ัั ะดะพะปะถะตะฝ ะฟะพะตั
ะฐัั ะบ ะฝะตะผั. (ะฟะพะตั
ะฐัั ะบ)
rus_verbs:ััะฝััััั{}, // ะผะพัะดะพะน ะถะธะฒะพัะฝะพะต ััะฝัะปะพัั ะบ ะทะตะผะปะต. (ััะฝััััั ะบ)
rus_verbs:ะะะะขะฌ{}, // ะถะดะธ ะธั
ะทะฐะฒััะฐ ะบ ัััั. (ะะะะขะฌ ะ)
rus_verbs:ะะะะะขะะขะฌ{}, // ะพะฝะธ ัััะตะผะธัะตะปัะฝะพ ะฟะพะปะตัะตะปะธ ะบ ะทะตะผะปะต. (ะะะะะขะะขะฌ ะ)
rus_verbs:ะฟะพะดะพะนัะธ{}, // ะฟะพะผะพะณะธ ะผะฝะต ะฟะพะดะพะนัะธ ะบ ััะพะปั. (ะฟะพะดะพะนัะธ ะบ)
rus_verbs:ะ ะะะะะ ะะฃะขะฌ{}, // ะผัะถะธะบ ัะฐะทะฒะตัะฝัะป ะบ ะฝะตะผั ะบะพะฝั. (ะ ะะะะะ ะะฃะขะฌ ะ)
rus_verbs:ะะ ะะะะะขะ{}, // ะฝะฐั ะฟัะธะฒะตะทะปะธ ะฟััะผะพ ะบ ะบะพัะพะปั. (ะะ ะะะะะขะ ะ)
rus_verbs:ะพัะฟััะฝััั{}, // ะฝะตะทะฝะฐะบะพะผะตั ะพัะฟััะฝัะป ะบ ััะตะฝะต. (ะพัะฟััะฝััั ะบ)
rus_verbs:ะฟะพะฑะตะถะฐัั{}, // Cะตัะณะตะน ะฟะพะฑะตะถะฐะป ะบ ะดะฒะตัะธ. (ะฟะพะฑะตะถะฐัั ะบ)
rus_verbs:ะพัะฑัะพัะธัั{}, // ัะธะปัะฝัะน ัะดะฐั ะพัะฑัะพัะธะป ะตะณะพ ะบ ััะตะฝะต. (ะพัะฑัะพัะธัั ะบ)
rus_verbs:ะะซะะฃะะะขะฌ{}, // ะพะฝะธ ะฒัะฝัะดะธะปะธ ะผะตะฝั ะบ ัะพัััะดะฝะธัะตััะฒั (ะะซะะฃะะะขะฌ ะ)
rus_verbs:ะฟะพะดััะฝััั{}, // ะพะฝ ะฟะพะดััะฝัะป ะบ ัะตะฑะต ัััะป ะธ ัะตะป ะฝะฐ ะฝะตะณะพ (ะฟะพะดััะฝััั ะบ)
rus_verbs:ัะพะนัะธ{}, // ะฟะพ ัะทะบะพะน ััะพะฟะธะฝะบะต ะฟััะฝะธะบะธ ัะพัะปะธ ะบ ัะตะบะต. (ัะพะนัะธ ะบ)
rus_verbs:ัะฒะปััััั{}, // ะฟะพ ะฝะพัะฐะผ ะบ ะฝะตะผั ัะฒะปัะปะธัั ะฟัะธะทัะฐะบะธ. (ัะฒะปััััั ะบ)
rus_verbs:ะะะะขะฌ{}, // ะปะตะดัะฝะพะน ะฒะตัะตั ะณะฝะฐะป ะธั
ะบ ัะณั. (ะะะะขะฌ ะ)
rus_verbs:ะะซะะะกะขะ{}, // ะพะฝะฐ ะฒัะฒะตะปะฐ ะฝะฐั ัะพัะฝะพ ะบ ะผะตััั. (ะะซะะะกะขะ ะ)
rus_verbs:ะฒัะตั
ะฐัั{}, // ะฟะพััะธ ััะฐะทั ะผั ะฒัะตั
ะฐะปะธ ะบ ัะตะบะต.
rus_verbs:ะฟะพะดะพะดะฒะธะณะฐัััั{}, // ะฟะพะดะพะดะฒะธะณะฐะนัั ะบ ะพะบะฝั
rus_verbs:ะฑัะพัะธัััั{}, // ะฑะพะปััะฐั ัะฐััั ะทะฐัะธัะฝะธะบะพะฒ ััะตะฝ ะฑัะพัะธะปะฐัั ะบ ะฒะพัะพัะฐะผ.
rus_verbs:ะฟัะตะดััะฐะฒะธัั{}, // ะะณะพ ะฟัะตะดััะฐะฒะธะปะธ ะบ ะพัะดะตะฝั.
rus_verbs:ะดะฒะธะณะฐัััั{}, // ะผะตะถะดั ัะตะผ ััะดะธัะต ะฝะตัะพัะพะฟะปะธะฒะพ ะดะฒะธะณะฐะปะพัั ะบ ะฑะตัะตะณั.
rus_verbs:ะฒััะบะพัะธัั{}, // ัะตะผ ะฒัะตะผะตะฝะตะผ ะพะฝะธ ะฒััะบะพัะธะปะธ ะบ ัะตะบะต.
rus_verbs:ะฒัะนัะธ{}, // ัะตะผ ะฒัะตะผะตะฝะตะผ ะพะฝะธ ะฒััะปะธ ะบ ะปะตััะฝะธัะต.
rus_verbs:ะฟะพััะฝััั{}, // ะะฐะปััะธะบ ัั
ะฒะฐัะธะป ะฒะตััะฒะบั ะธ ะฟะพััะฝัะป ะตั ะบ ัะตะฑะต.
rus_verbs:ะฟัะธะปะพะถะธัั{}, // ะฟัะธะปะพะถะธัั ะบ ะดะตัะฐะปะธ ะฟะพะฒััะตะฝะฝะพะต ััะธะปะธะต
rus_verbs:ะฟัะพะนัะธ{}, // ะฟัะพะนัะธ ะบ ััะพะนะบะต ัะตะณะธัััะฐัะธะธ (ััะพะนะบะฐ ัะตะณะธัััะฐัะธะธ - ะฟัะพะฒะตัะธัั ะฟัะพะฒะตัะบั)
rus_verbs:ะพัะฝะตััะธัั{}, // ะพัะฝะตััะธัั ะบ ะถะธะฒะพัะฝัะผ ั ัะพััััะฒะธะตะผ
rus_verbs:ะฟัะธะฒัะทะฐัั{}, // ะฟัะธะฒัะทะฐัั ะทะฐ ะปะฐะฟั ะฒะตัะตะฒะบะพะน ะบ ะบะพะปััะบั, ะฒะพัะบะฝััะพะผั ะฒ ะทะตะผะปั
rus_verbs:ะฟััะณะฐัั{}, // ะฟััะณะฐัั ะบ ั
ะพะทัะธะฝั ะฝะฐ ััะพะป
rus_verbs:ะฟัะธะณะปะฐัะฐัั{}, // ะฟัะธะณะปะฐัะฐัั ะบ ะดะพะบัะพัั
rus_verbs:ัะฒะฐัััั{}, // ะงัะถะธะต ะปัะดะธ ัะฒัััั ะบ ะฒะปะฐััะธ
rus_verbs:ะฟะพะฝะตััะธัั{}, // ะฟะพะฝะตััะธัั ะบ ะพะฑััะฒั
rus_verbs:ะฟะธัะฐัั{}, // ะฟะธัะฐัั ะฟัะธะฒัะทะฐะฝะฝะพััั ะบ ะฐะปะบะพะณะพะปั
rus_verbs:ะทะฐะตั
ะฐัั{}, // ะะพะปั ะทะฐะตั
ะฐะป ะบ ะะปะต
rus_verbs:ะฟะตัะตะตั
ะฐัั{}, // ะฟะตัะตะตั
ะฐัั ะบ ัะพะดะธัะตะปัะผ
rus_verbs:ะฟะพะปะทัะธ{}, // ะฟะพะปะทัะธ ะบ ะดะพัะพะณะต
rus_verbs:ัะฒะพะดะธัััั{}, // ัะฒะพะดะธัััั ะบ ัะปะตะผะตะฝัะฐัะฝะพะผั ะดะตะนััะฒะธั
rus_verbs:ะดะพะฑะฐะฒะปััั{}, // ะดะพะฑะฐะฒะปััั ะบ ะพะฑัะตะน ััะผะผะต
rus_verbs:ะฟะพะดะฑัะพัะธัั{}, // ะฟะพะดะฑัะพัะธัั ะบ ะฟะพัะพะปะบั
rus_verbs:ะฟัะธะทัะฒะฐัั{}, // ะฟัะธะทัะฒะฐัั ะบ ัะฟะพะบะพะนััะฒะธั
rus_verbs:ะฟัะพะฑะธัะฐัััั{}, // ะฟัะพะฑะธัะฐัััั ะบ ะฟะฐััะธะทะฐะฝะฐะผ
rus_verbs:ะพัะฒะตะทัะธ{}, // ะพัะฒะตะทัะธ ะบ ัะพะดะธัะตะปัะผ
rus_verbs:ะฟัะธะผะตะฝััััั{}, // ะฟัะธะผะตะฝััััั ะบ ััะฐะฒะฝะตะฝะธั
rus_verbs:ัั
ะพะดะธัััั{}, // ัั
ะพะดะธัััั ะบ ัะพัะฝะพะผั ัะตัะตะฝะธั
rus_verbs:ะดะพะฟััะบะฐัั{}, // ะดะพะฟััะบะฐัั ะบ ัะดะฐัะต ะทะฐัะตัะฐ
rus_verbs:ัะฒะตััะธ{}, // ัะฒะตััะธ ะบ ะฝัะปั
rus_verbs:ะฟัะธะดะฒะธะฝััั{}, // ะฟัะธะดะฒะธะฝััั ะบ ะผะฐะปััะธะบั
rus_verbs:ะฟะพะดะณะพัะพะฒะธัั{}, // ะฟะพะดะณะพัะพะฒะธัั ะบ ะฟะตัะฐัะธ
rus_verbs:ะฟะพะดะพะฑัะฐัััั{}, // ะฟะพะดะพะฑัะฐัััั ะบ ะพะปะตะฝั
rus_verbs:ะทะฐัะพัะพะฟะธัััั{}, // ะทะฐัะพัะพะฟะธัััั ะบ ะฒัั
ะพะดั
rus_verbs:ะฟัะธััะฐัั{}, // ะฟัะธััะฐัั ะบ ะฑะตัะตะณั
rus_verbs:ะฟะพะผะฐะฝะธัั{}, // ะฟะพะผะฐะฝะธัั ะบ ัะตะฑะต
rus_verbs:ะฟัะธะฟะฐััั{}, // ะฟัะธะฟะฐััั ะบ ะฐะปัะฐัั
rus_verbs:ะฟัะธัะฐัะธัั{}, // ะฟัะธัะฐัะธัั ะบ ัะตะฑะต ะดะพะผะพะน
rus_verbs:ะฟัะธะถะธะผะฐัั{}, // ะฟัะธะถะธะผะฐัั ะบ ะณััะดะธ
rus_verbs:ะฟะพะดัะตััั{}, // ะฟะพะดัะตััั ะบ ัะธะผะฟะฐัะธัะฝะพะน ะดะตะฒะพัะบะต
rus_verbs:ะฟัะธะดะฒะธะฝััััั{}, // ะฟัะธะดะฒะธะฝััััั ะบ ะพะบะฝั
rus_verbs:ะพัะฟััะบะฐัั{}, // ะพัะฟััะบะฐัั ะบ ะดััะณั
rus_verbs:ะฟัะธะณะฝััััั{}, // ะฟัะธะณะฝััััั ะบ ะทะตะผะปะต
rus_verbs:ะฟัะธัััะพะธัััั{}, // ะฟัะธัััะพะธัััั ะบ ะบะพะปะพะฝะฝะต
rus_verbs:ัะณัะตััะธ{}, // ัะณัะตััะธ ะบ ัะตะฑะต
rus_verbs:ัะดัะฐัั{}, // ัะดัะฐัั ะบ ััะณะฐะฝะฐะผ
rus_verbs:ะฟัะธะฑะฐะฒะธัััั{}, // ะฟัะธะฑะฐะฒะธัััั ะบ ะพะฑัะตะน ััะผะผะต
rus_verbs:ะฟัะธัะผะพััะตัััั{}, // ะฟัะธัะผะพััะตัััั ะบ ะฟะพะบัะฟะบะต
rus_verbs:ะฟะพะดะบะฐัะธัั{}, // ะฟะพะดะบะฐัะธัั ะบ ัััะผั
rus_verbs:ะบะปะพะฝะธัั{}, // ะบะปะพะฝะธัั ะบะพ ัะฝั
rus_verbs:ะฟัะพัะปะตะดะพะฒะฐัั{}, // ะฟัะพัะปะตะดะพะฒะฐัั ะบ ะฒัั
ะพะดั
rus_verbs:ะฟะพะดะพะดะฒะธะฝััั{}, // ะฟะพะดะพะดะฒะธะฝััั ะบ ัะตะฑะต
rus_verbs:ะฟัะธะผะตะฝััั{}, // ะฟัะธะผะตะฝััั ะบ ัะพัััะดะฝะธะบะฐะผ
rus_verbs:ะฟัะธะปัะฝััั{}, // ะฟัะธะปัะฝััั ะบ ัะบัะฐะฝะฐะผ
rus_verbs:ะฟะพะดะฒะธะฝััั{}, // ะฟะพะดะฒะธะฝััั ะบ ัะตะฑะต
rus_verbs:ะฟัะธะผัะฐัััั{}, // ะฟัะธะผัะฐัััั ะบ ะฟะฐะฟะต
rus_verbs:ะฟะพะดะบัะฐััััั{}, // ะฟะพะดะบัะฐััััั ะบ ะถะตััะฒะต
rus_verbs:ะฟัะธะฒัะทะฐัััั{}, // ะฟัะธะฒัะทะฐัััั ะบ ัะพะฑะฐะบะต
rus_verbs:ะทะฐะฑะธัะฐัั{}, // ะทะฐะฑะธัะฐัั ะบ ัะตะฑะต
rus_verbs:ะฟัะพัะฒะฐัััั{}, // ะฟัะพัะฒะฐัััั ะบ ะบะฐััะต
rus_verbs:ะฟัะธะบะฐัะฐัััั{}, // ะฟัะธะบะฐัะฐัััั ะบ ะบะพะถะต
rus_verbs:ัะฝะพัะธัั{}, // ัะฝะพัะธัั ะบ ัะตะฑะต
rus_verbs:ะฟะพะดััะฝััััั{}, // ะฟะพะดััะฝััััั ะบ ะผะตััั
rus_verbs:ะฟัะธะฒะพะทะธัั{}, // ะฟัะธะฒะพะทะธัั ะบ ะฒะตัะตัะธะฝะฐัั
rus_verbs:ะฟะพะดะฟะพะปะทัะธ{}, // ะฟะพะดะฟะพะปะทัะธ ะบ ะทะฐะนัั
rus_verbs:ะฟัะธะฑะปะธะทะธัั{}, // ะฟัะธะฑะปะธะทะธัั ะบ ะณะปะฐะทะฐะผ
rus_verbs:ะฟัะธะผะตะฝะธัั{}, // ะฟัะธะผะตะฝะธัั ะบ ััะฐะฒะฝะตะฝะธั ะฟัะพััะพะต ะฟัะตะพะฑัะฐะทะพะฒะฐะฝะธะต
rus_verbs:ะฟัะธะณะปัะดะตัััั{}, // ะฟัะธะณะปัะดะตัััั ะบ ะธะทะพะฑัะฐะถะตะฝะธั
rus_verbs:ะฟัะธะปะพะถะธัััั{}, // ะฟัะธะปะพะถะธัััั ะบ ัััะบะต
rus_verbs:ะฟัะธััะฐะฒะฐัั{}, // ะฟัะธััะฐะฒะฐัั ะบ ะดะตะฒัะพะฝะบะฐะผ
rus_verbs:ะทะฐะฟัะตัะฐัััั{}, // ะทะฐะฟัะตัะฐัััั ะบ ะฟะพะบะฐะทั
rus_verbs:ะฟัะธะฑะตะณะฐัั{}, // ะฟัะธะฑะตะณะฐัั ะบ ะฝะฐัะธะปะธั
rus_verbs:ะฟะพะฑัะดะธัั{}, // ะฟะพะฑัะดะธัั ะบ ะดะตะนััะฒะธัะผ
rus_verbs:ะฟัะธััะณะธะฒะฐัั{}, // ะฟัะธััะณะธะฒะฐัั ะบ ัะตะฑะต
rus_verbs:ะฟัะธัััะพะธัั{}, // ะฟัะธัััะพะธัั ะบ ะฟะพะปะตะทะฝะพะผั ะดะตะปั
rus_verbs:ะฟัะธะณะพะฒะพัะธัั{}, // ะฟัะธะณะพะฒะพัะธัั ะบ ัะผะตััะธ
rus_verbs:ัะบะปะพะฝััััั{}, // ัะบะปะพะฝััััั ะบ ะฟัะตะบัะฐัะตะฝะธั ัะฐะทัะฐะฑะพัะบะธ
rus_verbs:ะฟะพะดัะตะทะถะฐัั{}, // ะฟะพะดัะตะทะถะฐัั ะบ ะฒะพะบะทะฐะปั
rus_verbs:ะฟัะธะฒะฐะปะธัััั{}, // ะฟัะธะฒะฐะปะธัััั ะบ ะทะฐะฑะพัั
rus_verbs:ะฝะฐะบะปะพะฝััััั{}, // ะฝะฐะบะปะพะฝััััั ะบ ัะตะฝะบั
rus_verbs:ะฟะพะดะพัะฟะตัั{}, // ะฟะพะดะพัะฟะตัั ะบ ะพะฑะตะดั
rus_verbs:ะฟัะธะปะธะฟะฝััั{}, // ะฟัะธะปะธะฟะฝััั ะบ ะพะบะฝั
rus_verbs:ะฟัะธะฒะพะปะพัั{}, // ะฟัะธะฒะพะปะพัั ะบ ัะตะฑะต
rus_verbs:ััััะตะผะปััััั{}, // ััััะตะผะปััััั ะบ ะฒะตััะธะฝะต
rus_verbs:ะพัะบะฐัะธัััั{}, // ะพัะบะฐัะธัััั ะบ ะธัั
ะพะดะฝัะผ ะฟะพะทะธัะธัะผ
rus_verbs:ะฟะพะฑัะถะดะฐัั{}, // ะฟะพะฑัะถะดะฐัั ะบ ะดะตะนััะฒะธัะผ
rus_verbs:ะฟัะธัะบะฐะบะฐัั{}, // ะฟัะธัะบะฐะบะฐัั ะบ ะบะพัะผะตะถะบะต
rus_verbs:ะฟัะธัะผะฐััะธะฒะฐัััั{}, // ะฟัะธัะผะฐััะธะฒะฐัััั ะบ ะฝะพะฒะธัะบั
rus_verbs:ะฟัะธะถะธะผะฐัััั{}, // ะฟัะธะถะธะผะฐัััั ะบ ะฑะพััั
rus_verbs:ะถะฐัััั{}, // ะถะฐัััั ะบ ะพะณะฝั
rus_verbs:ะฟะตัะตะดะฒะธะฝััั{}, // ะฟะตัะตะดะฒะธะฝััั ะบ ะพะบะฝั
rus_verbs:ะดะพะฟััะบะฐัััั{}, // ะดะพะฟััะบะฐัััั ะบ ัะบะทะฐะผะตะฝะฐะผ
rus_verbs:ะฟัะธะบัะตะฟะธัั{}, // ะฟัะธะบัะตะฟะธัั ะบ ะบะพัะฟััั
rus_verbs:ะพัะฟัะฐะฒะปััั{}, // ะพัะฟัะฐะฒะปััั ะบ ัะฟะตัะธะฐะปะธััะฐะผ
rus_verbs:ะฟะตัะตะฑะตะถะฐัั{}, // ะฟะตัะตะฑะตะถะฐัั ะบ ะฒัะฐะณะฐะผ
rus_verbs:ะฟัะธััะพะฝััััั{}, // ะฟัะธััะพะฝััััั ะบ ัะตะปะธะบะฒะธะธ
rus_verbs:ะทะฐัะฟะตัะธัั{}, // ะทะฐัะฟะตัะธัั ะบ ัะตะผัะต
rus_verbs:ัะตะฒะฝะพะฒะฐัั{}, // ัะตะฒะฝะพะฒะฐัั ะบ ัะพะฟะตัะฝะธัะต
rus_verbs:ะฟะพะดัััะฟะธัั{}, // ะฟะพะดัััะฟะธัั ะบ ะณะพัะปั
rus_verbs:ัะฒะพะดะธัั{}, // ัะฒะพะดะธัั ะบ ะฒะตัะตัะธะฝะฐัั
rus_verbs:ะฟะพะฑัะพัะฐัั{}, // ะฟะพะฑัะพัะฐัั ะบ ะฝะพะณะฐะผ
rus_verbs:ะฟะพะดะฐะฒะฐัััั{}, // ะฟะพะดะฐะฒะฐัััั ะบ ัะถะธะฝั
rus_verbs:ะฟัะธะฟะธััะฒะฐัั{}, // ะฟัะธะฟะธััะฒะฐัั ะบ ะดะพััะธะถะตะฝะธัะผ
rus_verbs:ะพัะฝะพัะธัั{}, // ะพัะฝะพัะธัั ะบ ัะฐััะตะฝะธัะผ
rus_verbs:ะฟัะธะฝัั
ะฐัััั{}, // ะฟัะธะฝัั
ะฐัััั ะบ ะฐัะพะผะฐัะฐะผ
rus_verbs:ะฟะพะดัะฐัะธัั{}, // ะฟะพะดัะฐัะธัั ะบ ัะตะฑะต
rus_verbs:ะฟัะธัะปะพะฝะธัั{}, // ะฟัะธัะปะพะฝะธัั ะบ ััะตะฝะต
rus_verbs:ะฟะพะดะฟะปััั{}, // ะฟะพะดะฟะปััั ะบ ะฑัั
rus_verbs:ะพะฟะฐะทะดัะฒะฐัั{}, // ะพะฟะฐะทะดัะฒะฐัั ะบ ััะธะปะธััั
rus_verbs:ะฟัะธะผะบะฝััั{}, // ะฟัะธะผะบะฝััั ะบ ะดะตะพะผะฝัััะฐะฝัะฐะผ
rus_verbs:ััะตะบะฐัััั{}, // ััะตะบะฐัััั ะบ ััะตะฝะฐะผ ััััะผั
rus_verbs:ะฟะพะดะณะพัะพะฒะธัััั{}, // ะฟะพะดะณะพัะพะฒะธัััั ะบ ะผะฐัะฐัะพะฝั
rus_verbs:ะฟัะธะณะปัะดัะฒะฐัััั{}, // ะฟัะธะณะปัะดัะฒะฐัััั ะบ ะฝะพะฒะธัะบั
rus_verbs:ะฟัะธัะพะตะดะธะฝััััั{}, // ะฟัะธัะพะตะดะธะฝััััั ะบ ัะพะพะฑัะตััะฒั
rus_verbs:ะบะปะพะฝะธัััั{}, // ะบะปะพะฝะธัััั ะบะพ ัะฝั
rus_verbs:ะฟัะธะฒัะบะฐัั{}, // ะฟัะธะฒัะบะฐัั ะบ ั
ะพัะพัะตะผั
rus_verbs:ะฟัะธะฝัะดะธัั{}, // ะฟัะธะฝัะดะธัั ะบ ะผะธัั
rus_verbs:ัะฟะปััั{}, // ัะฟะปััั ะบ ะดะฐะปะตะบะพะผั ะฑะตัะตะณั
rus_verbs:ััะฐัะธัั{}, // ััะฐัะธัั ะบ ะดะตัะตะฝััะฐะผ
rus_verbs:ะฟัะธะฟะปััั{}, // ะฟัะธะฟะปััั ะบ ัะธะฝะธัั
rus_verbs:ะฟะพะดะฑะตะณะฐัั{}, // ะฟะพะดะฑะตะณะฐัั ะบ ั
ะพะทัะธะฝั
rus_verbs:ะปะธัะฐัััั{}, // ะปะธัะฐัััั ััะตะดััะฒ ะบ ัััะตััะฒะพะฒะฐะฝะธั
rus_verbs:ะฟัะธัััะฟะฐัั{}, // ะฟัะธัััะฟะฐัั ะบ ะพะฟะตัะฐัะธะธ
rus_verbs:ะฟัะพะฑัะถะดะฐัั{}, // ะฟัะพะฑัะถะดะฐัั ะปะตะบัะธะตะน ะธะฝัะตัะตั ะบ ะผะฐัะตะผะฐัะธะบะต
rus_verbs:ะฟะพะดะบะปััะธัั{}, // ะฟะพะดะบะปััะธัั ะบ ัััะฑะต
rus_verbs:ะฟะพะดะบะปััะธัััั{}, // ะฟะพะดะบะปััะธัััั ะบ ัะตัะธ
rus_verbs:ะฟัะธะปะธัั{}, // ะฟัะธะปะธัั ะบ ะปะธัั
rus_verbs:ััััะฐัััั{}, // ััััะฐัััั ะบ ัะพัะตะดัะผ
rus_verbs:ะฟัะธััะตะณะฝััั{}, // ะฟัะธััะตะณะฝััั ะบ ะบัะตัะปั
rus_verbs:ะฟัะธัะพะตะดะธะฝะธัั{}, // ะฟัะธัะพะตะดะธะฝะธัั ะบ ัะตัะธ
rus_verbs:ะพัะฑะตะถะฐัั{}, // ะพัะฑะตะถะฐัั ะบ ะฟัะพัะธะฒะพะฟะพะปะพะถะฝะพะน ััะตะฝะต
rus_verbs:ะฟะพะดะฒะตะทัะธ{}, // ะฟะพะดะฒะตะทัะธ ะบ ะฝะฐะฑะตัะตะถะฝะพะน
rus_verbs:ะฟัะธะฑะตะณะฝััั{}, // ะฟัะธะฑะตะณะฝััั ะบ ั
ะธััะพััะธ
rus_verbs:ะฟัะธััะธัั{}, // ะฟัะธััะธัั ะบ ััะฐะปะตัั
rus_verbs:ะฟะพะดัะฐะปะบะธะฒะฐัั{}, // ะฟะพะดัะฐะปะบะธะฒะฐัั ะบ ะฒัั
ะพะดั
rus_verbs:ะฟัะพััะฒะฐัััั{}, // ะฟัะพััะฒะฐัััั ะบ ะฒัั
ะพะดั
rus_verbs:ัะฒะพะทะธัั{}, // ัะฒะพะทะธัั ะบ ะฒะตัะตัะธะฝะฐัั
rus_verbs:ะทะฐัะตะผะตะฝะธัั{}, // ะทะฐัะตะผะตะฝะธัั ะบ ะฒัั
ะพะดั
rus_verbs:ะบัะตะฟะธัััั{}, // ะบัะตะฟะธัััั ะบ ะฟะพัะพะปะบั
rus_verbs:ะฟัะธะฑัะฐัั{}, // ะฟัะธะฑัะฐัั ะบ ััะบะฐะผ
rus_verbs:ะฟัะธัััะฐััะธัััั{}, // ะฟัะธัััะฐััะธัััั ะบ ะฝะฐัะบะพัะธะบะฐะผ
rus_verbs:ะฟะพัะฟะตัั{}, // ะฟะพัะฟะตัั ะบ ะพะฑะตะดั
rus_verbs:ะฟัะธะฒัะทัะฒะฐัั{}, // ะฟัะธะฒัะทัะฒะฐัั ะบ ะดะตัะตะฒั
rus_verbs:ะฟัะธะปะฐะณะฐัั{}, // ะฟัะธะปะฐะณะฐัั ะบ ะดะพะบัะผะตะฝัะฐะผ
rus_verbs:ะฟะตัะตะฟัะฐะฒะธัั{}, // ะฟะตัะตะฟัะฐะฒะธัั ะบ ะดะตะดััะบะต
rus_verbs:ะฟะพะดะพะณะฝะฐัั{}, // ะฟะพะดะพะณะฝะฐัั ะบ ะฒะพัะพัะฐะผ
rus_verbs:ััะณะพัะตัั{}, // ััะณะพัะตัั ะบ ัะพัะธะฐะปะธะทะผั
rus_verbs:ะฟะพะดะฑะธัะฐัััั{}, // ะฟะพะดะฑะธัะฐัััั ะบ ะพะปะตะฝั
rus_verbs:ะฟะพะดัััะฟะฐัั{}, // ะฟะพะดัััะฟะฐัั ะบ ะณะพัะปั
rus_verbs:ะฟัะธะผัะบะฐัั{}, // ะฟัะธะผัะบะฐัั ะบ ะฟะตัะฒะพะผั ัะปะตะผะตะฝัั
rus_verbs:ะฟัะธะปะฐะดะธัั{}, // ะฟัะธะปะฐะดะธัั ะบ ะฒะตะปะพัะธะฟะตะดั
rus_verbs:ะฟะพะดะฑัะฐััะฒะฐัั{}, // ะฟะพะดะฑัะฐััะฒะฐัั ะบ ะฟะพัะพะปะบั
rus_verbs:ะฟะตัะตะฒะพะทะธัั{}, // ะฟะตัะตะฒะพะทะธัั ะบ ะฝะพะฒะพะผั ะผะตััั ะดะธัะปะพะบะฐัะธะธ
rus_verbs:ััะฐะถะธะฒะฐัััั{}, // ััะฐะถะธะฒะฐัััั ะบ ะพะบะฝั
rus_verbs:ะฟัะธะฑะปะธะถะฐัั{}, // ะฟัะธะฑะปะธะถะฐัั ะบ ะณะปะฐะทะฐะผ
rus_verbs:ะฟะพะฟัะพัะธัััั{}, // ะฟะพะฟัะพัะธัััั ะบ ะฑะฐะฑััะบะต
rus_verbs:ะฟัะธะฑะธัั{}, // ะฟัะธะฑะธัั ะบ ะดะพัะบะต
rus_verbs:ะฟะตัะตัะฐัะธัั{}, // ะฟะตัะตัะฐัะธัั ะบ ัะตะฑะต
rus_verbs:ะฟัะธัะตะฟะธัั{}, // ะฟัะธัะตะฟะธัั ะบ ะฟะฐัะพะฒะพะทั
rus_verbs:ะฟัะธะบะปะฐะดัะฒะฐัั{}, // ะฟัะธะบะปะฐะดัะฒะฐัั ะบ ัะฐะฝะต
rus_verbs:ัััะฐัะตัั{}, // ัััะฐัะตัั ะบ ะฝะฐัะฐะปั ะฒะพะนะฝั
rus_verbs:ะฟัะธัะฐะปะธัั{}, // ะฟัะธัะฐะปะธัั ะบ ะฟัะธััะฐะฝะธ
rus_verbs:ะฟัะธัะฟะพัะพะฑะธัััั{}, // ะฟัะธัะฟะพัะพะฑะธัััั ะบ ะพะฟะพะทะดะฐะฝะธัะผ
rus_verbs:ะฟัะธะฝัะถะดะฐัั{}, // ะฟัะธะฝัะถะดะฐัั ะบ ะผะธัั
rus_verbs:ัะพะฒะฐัััั{}, // ัะพะฒะฐัััั ะบ ะดะธัะตะบัะพัั
rus_verbs:ะฟัะพัะพะปะบะฐัััั{}, // ะฟัะพัะพะปะบะฐัััั ะบ ะฟัะธะปะฐะฒะบั
rus_verbs:ะฟัะธะบะพะฒะฐัั{}, // ะฟัะธะบะพะฒะฐัั ะบ ะฑะฐัะฐัะตะต
rus_verbs:ะฟะพะดะบัะฐะดัะฒะฐัััั{}, // ะฟะพะดะบัะฐะดัะฒะฐัััั ะบ ัััะปะธะบั
rus_verbs:ะฟะพะดัะฐะดะธัั{}, // ะฟะพะดัะฐะดะธัั ะบ ะฐัะตััะพะฝัั
rus_verbs:ะฟัะธะบะฐัะธัั{}, // ะฟัะธะบะฐัะธัั ะบ ัะธะฝะธัั
rus_verbs:ะฟัะพัะฐัะธัั{}, // ะฟัะพัะฐัะธัั ะบ ะฒะปะฐะดัะบะต
rus_verbs:ััะถะฐัััั{}, // ััะถะฐัััั ะบ ะพัะฝะพะฒะฐะฝะธั
rus_verbs:ะฟัะธัะพะฒะพะบัะฟะธัั{}, // ะฟัะธัะพะฒะพะบัะฟะธัั ะบ ะฟะพะถะตะปะฐะฝะธัะผ
rus_verbs:ะฟัะธะณะฒะพะทะดะธัั{}, // ะฟัะธะณะฒะพะทะดะธัั ะบ ะดะพัะบะต
rus_verbs:ะพัััะปะฐัั{}, // ะพัััะปะฐัั ะบ ะฟะตัะฒะพะธััะพัะฝะธะบั
rus_verbs:ะธะทะณะพัะพะฒะธัััั{}, // ะธะทะณะพัะพะฒะธัััั ะบ ะฟััะถะบั
rus_verbs:ะฟัะธะปะฐะณะฐัััั{}, // ะฟัะธะปะฐะณะฐัััั ะบ ะฟะพะบัะฟะบะต
rus_verbs:ะฟัะธัะตะฟะธัััั{}, // ะฟัะธัะตะฟะธัััั ะบ ะฒะฐะณะพะฝั
rus_verbs:ะฟัะธะผะตัะธะฒะฐัััั{}, // ะฟัะธะผะตัะธะฒะฐัััั ะบ ะฒะธะฝั
rus_verbs:ะฟะตัะตัะตะปะธัั{}, // ะฟะตัะตัะตะปะธัั ะบ ััะฐััะตะบัััะฝะธะบะฐะผ
rus_verbs:ะทะฐััััะธัั{}, // ะทะฐััััะธัั ะบ ะฒัั
ะพะดะต
rus_verbs:ะฟัะธัะฟะพัะพะฑะธัั{}, // ะฟัะธัะฟะพัะพะฑะธัั ะบ ะพะฑะพะณัะตะฒั
rus_verbs:ะฟัะธะผะตัะธัััั{}, // ะฟัะธะผะตัะธัััั ะบ ะฐะฟะฟะฐัะฐัั
rus_verbs:ะฟัะธะฑะฐะฒะปััััั{}, // ะฟัะธะฑะฐะฒะปััััั ะบ ะฟะตะฝัะธะธ
rus_verbs:ะฟะพะดะบะฐัะธัััั{}, // ะฟะพะดะบะฐัะธัััั ะบ ะฒะพัะพัะฐะผ
rus_verbs:ัััะณะธะฒะฐัั{}, // ัััะณะธะฒะฐัั ะบ ะณัะฐะฝะธัะต
rus_verbs:ะดะพะฟะธัะฐัั{}, // ะดะพะฟะธัะฐัั ะบ ัะพะผะฐะฝั
rus_verbs:ะฟะพะดะฟัััะธัั{}, // ะฟะพะดะฟัััะธัั ะบ ะบะพัะพะฒะต
rus_verbs:ัะบะปะพะฝััั{}, // ัะบะปะพะฝััั ะบ ัะพัััะดะฝะธัะตััะฒั
rus_verbs:ะฟัะธะฟะตัะฐัะฐัั{}, // ะฟัะธะฟะตัะฐัะฐัั ะบ ััะตะฝะต
rus_verbs:ะพั
ะปะฐะดะตัั{}, // ะพั
ะปะฐะดะตัั ะบ ะผัะทัะบะต
rus_verbs:ะฟัะธัะธัั{}, // ะฟัะธัะธัั ะบ ัะธะฝะตะปะธ
rus_verbs:ะฟัะธะฝัั
ะธะฒะฐัััั{}, // ะฟัะธะฝัั
ะธะฒะฐัััั ะบ ะฒะตััั
rus_verbs:ะฟะพะดััะปะธัั{}, // ะฟะพะดััะปะธัั ะบ ะฑะฐัััะฝะต
rus_verbs:ะฝะฐะฒะตะดะฐัััั{}, // ะฝะฐะฒะตะดะฐัััั ะบ ะพัะฐะบัะปั
rus_verbs:ะบะปะตะธัััั{}, // ะบะปะตะธัััั ะบ ะบะพะฝะฒะตััั
rus_verbs:ะฟะตัะตััะฝััั{}, // ะฟะตัะตััะฝััั ะบ ัะตะฑะต
rus_verbs:ะฟะตัะตะผะตัะฝััััั{}, // ะฟะตัะตะผะตัะฝััััั ะบ ะบะพะฝะบััะตะฝัะฐะผ
rus_verbs:ะปะธะฟะฝััั{}, // ะปะธะฟะฝััั ะบ ัะพะบัััะฝะธัะฐะผ
rus_verbs:ะฟะพะบะพะฒััััั{}, // ะฟะพะบะพะฒััััั ะบ ะฒัั
ะพะดั
rus_verbs:ะฟะพะดะฟััะบะฐัั{}, // ะฟะพะดะฟััะบะฐัั ะบ ะฟัะปััั ัะฟัะฐะฒะปะตะฝะธั
rus_verbs:ะฟัะธัะพัะฐัััั{}, // ะฟัะธัะพัะฐัััั ะบ ะธััะพัะฝะธะบั
rus_verbs:ะฟัะธะบะปะตะธัั{}, // ะฟัะธะบะปะตะธัั ะบ ััะตะบะปั
rus_verbs:ะฟะพะดััะณะธะฒะฐัั{}, // ะฟะพะดััะณะธะฒะฐัั ะบ ัะตะฑะต
rus_verbs:ะฟะพะดะบะฐััะฒะฐัั{}, // ะฟะพะดะบะฐััะฒะฐัั ะบ ะดะฐะผะต
rus_verbs:ะฟัะธััะฐะณะธะฒะฐัััั{}, // ะฟัะธััะฐะณะธะฒะฐัััั ะบ ะพะฟัั
ะพะปะธ
rus_verbs:ัะปะตัะฐัััั{}, // ัะปะตัะฐัััั ะบ ะฒะพะดะพะฟะพั
rus_verbs:ั
ะฐะถะธะฒะฐัั{}, // ั
ะฐะถะธะฒะฐัั ะบ ะฑะฐัััะบะต
rus_verbs:ะฟัะธะฒะปะตะบะฐัััั{}, // ะฟัะธะฒะปะตะบะฐัััั ะบ ะฐะดะผะธะฝะธัััะฐัะธะฒะฝะพะน ะพัะฒะตัััะฒะตะฝะฝะพััะธ
rus_verbs:ะฟะพะดะทัะฒะฐัั{}, // ะฟะพะดะทัะฒะฐัั ะบ ัะตะฑะต
rus_verbs:ะฟัะธะบะปะฐะดัะฒะฐัััั{}, // ะฟัะธะบะปะฐะดัะฒะฐัััั ะบ ะธะบะพะฝะต
rus_verbs:ะฟะพะดััะณะธะฒะฐัััั{}, // ะฟะพะดััะณะธะฒะฐัััั ะบ ะฟะฐัะปะฐะผะตะฝัั
rus_verbs:ะฟัะธะปะตะฟะธัั{}, // ะฟัะธะปะตะฟะธัั ะบ ััะตะฝะบะต ั
ะพะปะพะดะธะปัะฝะธะบะฐ
rus_verbs:ะฟะพะดะพะดะฒะธะฝััััั{}, // ะฟะพะดะพะดะฒะธะฝััััั ะบ ัะบัะฐะฝั
rus_verbs:ะฟัะธะฟะพะปะทัะธ{}, // ะฟัะธะฟะพะปะทัะธ ะบ ะดะตัะตะฒั
rus_verbs:ะทะฐะฟะฐะทะดัะฒะฐัั{}, // ะทะฐะฟะฐะทะดัะฒะฐัั ะบ ะพะฑะตะดั
rus_verbs:ะฟัะธะฟะตัะตัั{}, // ะฟัะธะฟะตัะตัั ะบ ััะตะฝะต
rus_verbs:ะฝะฐะณะธะฑะฐัััั{}, // ะฝะฐะณะธะฑะฐัััั ะบ ัะฒะตัะบั
ะธะฝัะธะฝะธัะธะฒ:ัะณะพะฝััั{ ะฒะธะด:ัะพะฒะตัั }, ะณะปะฐะณะพะป:ัะณะพะฝััั{ ะฒะธะด:ัะพะฒะตัั }, // ัะณะพะฝััั ะบ ะฒะพัะพัะฐะผ
ะดะตะตะฟัะธัะฐััะธะต:ัะณะพะฝัะฒ{},
rus_verbs:ะฟะพะบะพะฒัะปััั{}, // ะฟะพะบะพะฒัะปััั ะบ ะฒัั
ะพะดั
rus_verbs:ะฟัะธะฒะฐะปะธัั{}, // ะฟัะธะฒะฐะปะธัั ะบ ััะพะปะฑั
rus_verbs:ะพัะฟัะพัะธัััั{}, // ะพัะฟัะพัะธัััั ะบ ัะพะดะธัะตะปัะผ
rus_verbs:ะฟัะธัะฟะพัะฐะฑะปะธะฒะฐัััั{}, // ะฟัะธัะฟะพัะฐะฑะปะธะฒะฐัััั ะบ ะฝะพะฒัะผ ััะปะพะฒะธัะผ
rus_verbs:ะฟัะธะปะธะฟะฐัั{}, // ะฟัะธะปะธะฟะฐัั ะบ ััะบะฐะผ
rus_verbs:ะฟะพะดัะพะตะดะธะฝะธัั{}, // ะฟะพะดัะพะตะดะธะฝะธัั ะบ ะฟัะธะฑะพัะฐะผ
rus_verbs:ะฟัะธะปะธะฒะฐัั{}, // ะฟัะธะปะธะฒะฐัั ะบ ะณะพะปะพะฒะต
rus_verbs:ะฟะพะดัะตะปะธัั{}, // ะฟะพะดัะตะปะธัั ะบ ะดััะณะธะผ ะฝะพะฒะธัะบะฐะผ
rus_verbs:ะฟัะธะปะตะฟะธัััั{}, // ะฟัะธะปะตะฟะธัััั ะบ ัะบััะต
rus_verbs:ะฟะพะดะปะตัะฐัั{}, // ะฟะพะดะปะตัะฐัั ะบ ะฟัะฝะบัั ะฝะฐะทะฝะฐัะตะฝะธั
rus_verbs:ะฟัะธััะตะณะฝััััั{}, // ะฟัะธััะตะณะฝััััั ะบ ะบัะตัะปั ัะตะผะฝัะผะธ
rus_verbs:ะฟัะธะฑะธัััั{}, // ะฟัะธะฑะธัััั ะบ ััะฐะต, ัะปะตัะฐััะตะน ะฝะฐ ัะณ
rus_verbs:ะปัะฝััั{}, // ะปัะฝััั ะบ ะทะฐะฑะพัะปะธะฒะพะผั ั
ะพะทัะธะฝั
rus_verbs:ะฟัะธะฒัะทัะฒะฐัััั{}, // ะฟัะธะฒัะทัะฒะฐัััั ะบ ะปัะฑััะตะผั ั
ะพะทัะธะฝั
rus_verbs:ะฟัะธะบะปะตะธัััั{}, // ะฟัะธะบะปะตะธัััั ะบ ัะฟะธะฝะต
rus_verbs:ัััะณะธะฒะฐัััั{}, // ัััะณะธะฒะฐัััั ะบ ัะตะฝะฐัั
rus_verbs:ะฟะพะดะณะพัะฐะฒะปะธะฒะฐัั{}, // ะฟะพะดะณะพัะฐะฒะปะธะฒะฐัั ะบ ะฒัั
ะพะดั ะฝะฐ ะฐัะตะฝั
rus_verbs:ะฟัะธะณะปะฐัะฐัััั{}, // ะฟัะธะณะปะฐัะฐัััั ะบ ะดะพะบัะพัั
rus_verbs:ะฟัะธัะธัะปััั{}, // ะฟัะธัะธัะปััั ะบ ะพัะปะธัะฝะธะบะฐะผ
rus_verbs:ะฟัะธะบะพะปะพัั{}, // ะฟัะธะบะพะปะพัั ะบ ะปะฐัะบะฐะฝั
rus_verbs:ะฝะฐะบะปะพะฝััั{}, // ะฝะฐะบะปะพะฝััั ะบ ะณะพัะธะทะพะฝัั
rus_verbs:ะฟัะธะฟะฐะดะฐัั{}, // ะฟัะธะฟะฐะดะฐัั ะบ ะฟะตัะฒะพะธััะพัะฝะธะบั
rus_verbs:ะฟัะธะพะฑัะธัััั{}, // ะฟัะธะพะฑัะธัััั ะบ ะบัะปััััะฝะพะผั ะฝะฐัะปะตะดะธั
rus_verbs:ะฟัะธะดะธัะฐัััั{}, // ะฟัะธะดะธัะฐัััั ะบ ะผะตะปะบะธะผ ะพัะธะฑะบะฐะผ
rus_verbs:ะฟัะธััะฐัั{}, // ะฟัะธััะฐัั ะบ ะปะพัะบั
rus_verbs:ะฟัะพะผะพัะฐัั{}, // ะฟัะพะผะพัะฐัั ะบ ะฝะฐัะฐะปั
rus_verbs:ะฟัะธั
ะปัะฝััั{}, // ะฟัะธั
ะปัะฝััั ะบ ะณะพะปะพะฒะต
rus_verbs:ะฟัะธัะฒะฐััะพะฒะฐัััั{}, // ะฟัะธัะฒะฐััะพะฒะฐัััั ะบ ะฟะตัะฒะพะผั ะฟะธััั
rus_verbs:ะฟัะธะบัััะธัั{}, // ะฟัะธะบัััะธัั ะบ ะฒะตะปะพัะธะฟะตะดั
rus_verbs:ะฟะพะดะฟะปัะฒะฐัั{}, // ะฟะพะดะฟะปัะฒะฐัั ะบ ะปะพะดะบะต
rus_verbs:ะฟัะธัะฐะฒะฝะธะฒะฐัััั{}, // ะฟัะธัะฐะฒะฝะธะฒะฐัััั ะบ ะฟะพะฑะตะณั
rus_verbs:ะฟะพะดัััะตะบะฐัั{}, // ะฟะพะดัััะตะบะฐัั ะบ ะฒะพะพััะถะตะฝะฝะพะน ะฑะพััะฑะต ั ะพะบะบัะฟะฐะฝัะฐะผะธ
rus_verbs:ะธะทะณะพัะพะฒะปััััั{}, // ะธะทะณะพัะพะฒะปััััั ะบ ะฟััะถะบั ะธะท ัััะฐัะพััะตัั
rus_verbs:ะฟัะธัะบะฝััััั{}, // ะฟัะธัะบะฝััััั ะบ ะฟะตัะฒะพะน ะณััะฟะฟะต ัััะธััะพะฒ
rus_verbs:ะฟัะธัััะธัั{}, // ะฟัะธัััะธัั ะบะพัะธะบะฐ ะบ ะปะพัะบั
rus_verbs:ะฟัะธะบะพะฒัะฒะฐัั{}, // ะฟัะธะบะพะฒัะฒะฐัั ะบ ัะตะฑะต ะฒัะต ะฒะฝะธะผะฐะฝะธะต ะฟัะตััั
rus_verbs:ะฟัะธะณะพัะพะฒะปััััั{}, // ะฟัะธะณะพัะพะฒะปััััั ะบ ะฟะตัะฒะพะผั ัะบะทะฐะผะตะฝั
rus_verbs:ะพััััั{}, // ะะพะดะฐ ะพัััะฝะตั ะบ ัััั.
rus_verbs:ะฟัะธะตั
ะฐัั{}, // ะะฝ ะฟัะธะตะดะตั ะบ ะบะพะฝัั ะฑัะดััะตะน ะฝะตะดะตะปะธ.
rus_verbs:ะฟะพะดัะฐะถะธะฒะฐัััั{},
rus_verbs:ััะฟะตะฒะฐัั{}, // ััะฟะตะฒะฐัั ะบ ััะธะปะธััั
rus_verbs:ะฟัะธะฒะปะตะบะฐัั{}, // ะฟัะธะฒะปะตะบะฐัั ะบ ัะตะฑะต ะฒะฝะธะผะฐะฝะธะต
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัััะพะนัะธะฒัะน{}, // ะฟะตัะตะฒะพะดะธัั ะฒ ัััะพะนัะธะฒัั ะบ ะฟะตัะตะณัะตะฒั ัะพัะผั
rus_verbs:ะฟัะธะนัะธัั{}, // ะฟัะธะนัะธัั ะบะพ ะดะฒะพัั
ะธะฝัะธะฝะธัะธะฒ:ะฐะดะฐะฟัะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะผะฐัะธะฝะฐ ะฑัะปะฐ ะฐะดะฐะฟัะธัะพะฒะฐะฝะฐ ะบ ััะปะพะฒะธัะผ ะบัะฐะนะฝะตะณะพ ัะตะฒะตัะฐ
ะธะฝัะธะฝะธัะธะฒ:ะฐะดะฐะฟัะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฐะดะฐะฟัะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฐะดะฐะฟัะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ะฐะดะฐะฟัะธัะพะฒะฐะฒ{},
ะดะตะตะฟัะธัะฐััะธะต:ะฐะดะฐะฟัะธััั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธััััะธะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธัะพะฒะฐะฒัะธะน{ ะฒะธะด:ัะพะฒะตัั },
//+ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธัะพะฒะฐะฒัะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธัะพะฒะฐะฝะฝัะน{},
ะธะฝัะธะฝะธัะธะฒ:ะฐะดะฐะฟัะธัะพะฒะฐัััั{ะฒะธะด:ัะพะฒะตัั}, // ัะตะปะพ ะฐะดะฐะฟัะธัะพะฒะฐะปะพัั ะบ ััะปะพะฒะธัะผ ัััะพะฒะพะน ะทะธะผั
ะธะฝัะธะฝะธัะธะฒ:ะฐะดะฐะฟัะธัะพะฒะฐัััั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฐะดะฐะฟัะธัะพะฒะฐัััั{ะฒะธะด:ัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฐะดะฐะฟัะธัะพะฒะฐัััั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ะฐะดะฐะฟัะธัะพะฒะฐะฒัะธัั{},
ะดะตะตะฟัะธัะฐััะธะต:ะฐะดะฐะฟัะธััััั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธัะพะฒะฐะฒัะธะนัั{ะฒะธะด:ัะพะฒะตัั},
//+ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธัะพะฒะฐะฒัะธะนัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธััััะธะนัั{},
rus_verbs:ะฐะฟะตะปะปะธัะพะฒะฐัั{}, // ะพัะฐัะพั ะฐะฟะตะปะปะธัะพะฒะฐะป ะบ ะฟะฐััะธะพัะธะทะผั ัะฒะพะธั
ัะปััะฐัะตะปะตะน
rus_verbs:ะฑะปะธะทะธัััั{}, // ะจัะพัะผ ะฑะปะธะทะธััั ะบ ะฟะพะฑะตัะตะถัั
rus_verbs:ะดะพััะฐะฒะธัั{}, // ะญัะบะธะท ัะฐะบะตัั, ัะฟะพัะพะฑะฝะพะน ะดะพััะฐะฒะธัั ะบะพัะฐะฑะปั ะบ ะัะฝะต
rus_verbs:ะฑัะบัะธัะพะฒะฐัั{}, // ะัะบัะธั ะฑัะบัะธััะตั ัะฐะฝะบะตั ะบ ะผะตััั ััะพัะฝะบะธ
rus_verbs:ะฟัะธัะธัะปะธัั{}, // ะั ะฟัะธัะธัะปะธะปะธ ะตะณะพ ะบ ัะธัะปั ัะบัะฟะตััะพะฒ
rus_verbs:ะฒะตััะธ{}, // ะะฐัะฐ ะฟะฐััะธั ะฒะตะดะตั ะฝะฐัะพะด ะบ ะฟัะพัะฒะตัะฐะฝะธั
rus_verbs:ะฒะทัะฒะฐัั{}, // ะฃัะธัะตะปั ะฒะทัะฒะฐัั ะบ ัะพะฒะตััะธ ั
ัะปะธะณะฐะฝะฐ
rus_verbs:ะฒะพะทะทะฒะฐัั{}, // ะฒะพะทะทะฒะฐัั ัะพะฟะปะตะผะตะฝะฝะธะบะพะฒ ะบ ะพััะถะธั
rus_verbs:ะฒะพะทัะตะฒะฝะพะฒะฐัั{}, // ะฒะพะทัะตะฒะฝะพะฒะฐัั ะบ ะฟะพะบะปะพะฝะฝะธะบะฐะผ
rus_verbs:ะฒะพัะฟัะปะฐัั{}, // ะะพะปั ะฒะพัะฟัะปะฐะป ะบ ะะปะต ัััะฐััะฝะพะน ะปัะฑะพะฒัั
rus_verbs:ะฒะพัั
ะพะดะธัั{}, // ะฒะพัั
ะพะดะธัั ะบ ะฒะตััะธะฝะต
rus_verbs:ะฒะพััะตััะฒะพะฒะฐัั{}, // ะฒะพััะตััะฒะพะฒะฐัั ะบ ะฒะตััะธะฝะต
rus_verbs:ััะฟะตัั{}, // ััะฟะตัั ะบ ะพะฑะตะดั
rus_verbs:ะฟะพะฒะตัะฝััััั{}, // ะฟะพะฒะตัะฝััััั ะบ ะบะพะผั-ัะพ
rus_verbs:ะพะฑัะฐัะธัััั{}, // ะพะฑัะฐัะธัััั ะบ ะพั
ัะฐะฝะฝะธะบั
rus_verbs:ะทะฒะฐัั{}, // ะทะฒะฐัั ะบ ััะพะปั
rus_verbs:ะพัะฟัะฐะฒะธัััั{}, // ะพัะฟัะฐะฒะธัััั ะบ ะฟะฐัะธะบะผะฐั
ะตัั
rus_verbs:ะพะฑะตัะฝััััั{}, // ะพะฑะตัะฝััััั ะบ ะทะพะฒััะตะผั
rus_verbs:ัะฒะธัััั{}, // ัะฒะธัััั ะบ ัะปะตะดะพะฒะฐัะตะปั
rus_verbs:ัะตั
ะฐัั{}, // ัะตั
ะฐัั ะบ ัะพะดะฝะต
rus_verbs:ะฟัะธะฑััั{}, // ะฟัะธะฑััั ะบ ะฟะตัะตะบะปะธัะบะต
rus_verbs:ะฟัะธะฒัะบะฝััั{}, // ะฟัะธะฒัะบะฝััั ะบ ะณะพะปะพะดั
rus_verbs:ัั
ะพะดะธัั{}, // ัั
ะพะดะธัั ะบ ััะณะฐะฝะฐะผ
rus_verbs:ะฟัะธะฒะตััะธ{}, // ะฟัะธะฒะตััะธ ะบ ัะตะฑะต
rus_verbs:ัะฐะณะฝััั{}, // ัะฐะณะฝััั ะบ ัะปะฐะฒะต
rus_verbs:ะพัะฝะพัะธัััั{}, // ะพัะฝะพัะธัััั ะบ ะฟัะตะถะฝะธะผ ะฟะตัะธะพะดะฐะผ
rus_verbs:ะฟะพะดะพัะปะฐัั{}, // ะฟะพะดะพัะปะฐัั ะบ ะฒัะฐะณะฐะผ
rus_verbs:ะฟะพัะฟะตัะธัั{}, // ะฟะพัะฟะตัะธัั ะบ ะพะฑะตะดั
rus_verbs:ะทะฐะนัะธ{}, // ะทะฐะนัะธ ะบ ะฟะพะดััะณะต
rus_verbs:ะฟะพะทะฒะฐัั{}, // ะฟะพะทะฒะฐัั ะบ ัะตะฑะต
rus_verbs:ะฟะพััะฝััััั{}, // ะฟะพััะฝััััั ะบ ัััะฐะณะฐะผ
rus_verbs:ะฟััะบะฐัั{}, // ะฟััะบะฐัั ะบ ัะตะฑะต
rus_verbs:ะพัะฒะตััะธ{}, // ะพัะฒะตััะธ ะบ ะฒัะฐัั
rus_verbs:ะฟัะธะฑะปะธะทะธัััั{}, // ะฟัะธะฑะปะธะทะธัััั ะบ ัะตัะตะฝะธั ะทะฐะดะฐัะธ
rus_verbs:ะฟัะธะถะฐัั{}, // ะฟัะธะถะฐัั ะบ ััะตะฝะต
rus_verbs:ะพัะฟัะฐะฒะธัั{}, // ะพัะฟัะฐะฒะธัั ะบ ะดะพะบัะพัั
rus_verbs:ะฟะฐะดะฐัั{}, // ะฟะฐะดะฐัั ะบ ะผะฝะพะณะพะปะตัะฝะธะผ ะผะธะฝะธะผัะผะฐะผ
rus_verbs:ะฟะพะปะตะทัั{}, // ะฟะพะปะตะทัั ะบ ะดะตัััะธะผัั
rus_verbs:ะปะตะทัั{}, // ะขั ัะฐะผะฐ ะบะพ ะผะฝะต ะปะตะทะปะฐ!
rus_verbs:ะฝะฐะฟัะฐะฒะธัั{}, // ะฝะฐะฟัะฐะฒะธัั ะบ ะผะฐะนะพัั
rus_verbs:ะฟัะธะฒะพะดะธัั{}, // ะฟัะธะฒะพะดะธัั ะบ ะดะฐะฝัะธััั
rus_verbs:ะบะธะฝััััั{}, // ะบะธะฝััััั ะบ ะดะฒะตัะธ
rus_verbs:ะฟะพะดะฝะตััะธ{}, // ะฟะพะดะฝะตััะธ ะบ ะณะปะฐะทะฐะผ
rus_verbs:ะฟะพะดะฝะธะผะฐัััั{}, // ะฟะพะดะฝะธะผะฐัััั ะบ ัะตะฑะต
rus_verbs:ะฟัะธะฑะฐะฒะธัั{}, // ะฟัะธะฑะฐะฒะธัั ะบ ัะตะทัะปััะฐัั
rus_verbs:ะทะฐัะฐะณะฐัั{}, // ะทะฐัะฐะณะฐัั ะบ ะฒัั
ะพะดั
rus_verbs:ัะบะปะพะฝะธัััั{}, // ัะบะปะพะฝะธัััั ะบ ะทะตะผะปะต
rus_verbs:ัััะตะผะธัััั{}, // ัััะตะผะธัััั ะบ ะฒะตััะธะฝะต
rus_verbs:ะปะตัะตัั{}, // ะปะตัะตัั ะบ ัะพะดััะฒะตะฝะฝะธะบะฐะผ
rus_verbs:ะตะทะดะธัั{}, // ะตะทะดะธัั ะบ ะปัะฑะพะฒะฝะธัะต
rus_verbs:ะฟัะธะฑะปะธะถะฐัััั{}, // ะฟัะธะฑะปะธะถะฐัััั ะบ ัะธะฝะธัะต
rus_verbs:ะฟะพะผัะฐัััั{}, // ะฟะพะผัะฐัััั ะบ ััะพะผะฐัะพะปะพะณั
rus_verbs:ะฟัะธัะปััะฐัััั{}, // ะฟัะธัะปััะฐัััั ะบ ะฟัะพะธัั
ะพะดััะตะผั
rus_verbs:ะธะทะผะตะฝะธัั{}, // ะธะทะผะตะฝะธัั ะบ ะปัััะตะผั ัะพะฑััะฒะตะฝะฝัั ะถะธะทะฝั
rus_verbs:ะฟัะพัะฒะธัั{}, // ะฟัะพัะฒะธัั ะบ ะฟะพะณะธะฑัะธะผ ัะพัััะฐะดะฐะฝะธะต
rus_verbs:ะฟะพะดะฑะตะถะฐัั{}, // ะฟะพะดะฑะตะถะฐัั ะบ ัะฟะฐะฒัะตะผั
rus_verbs:ัะตัััั{}, // ัะตัััั ะบ ะฟะฐััะฝะตัะฐะผ ะดะพะฒะตัะธะต
rus_verbs:ะฟัะพะฟัััะธัั{}, // ะฟัะพะฟัััะธัั ะบ ะฟะตะฒัั
rus_verbs:ะฟะพะดะฒะตััะธ{}, // ะฟะพะดะฒะตััะธ ะบ ะณะปะฐะทะฐะผ
rus_verbs:ะผะตะฝััััั{}, // ะผะตะฝััััั ะบ ะปัััะตะผั
rus_verbs:ะทะฐั
ะพะดะธัั{}, // ะทะฐั
ะพะดะธัั ะบ ะดััะณั
rus_verbs:ัะฒะฐะฝััััั{}, // ัะฒะฐะฝััััั ะบ ะฒะพะดะต
rus_verbs:ะฟัะธะฒะปะตัั{}, // ะฟัะธะฒะปะตัั ะบ ัะตะฑะต ะฒะฝะธะผะฐะฝะธะต
rus_verbs:ะฟัะธัะพะตะดะธะฝะธัััั{}, // ะฟัะธัะพะตะดะธะฝะธัััั ะบ ัะตัะธ
rus_verbs:ะฟัะธะตะทะถะฐัั{}, // ะฟัะธะตะทะถะฐัั ะบ ะดะตะดััะบะต
rus_verbs:ะดะตัะฝััััั{}, // ะดะตัะฝััััั ะบ ะฑะพััั
rus_verbs:ะฟะพะดัะตั
ะฐัั{}, // ะฟะพะดัะตั
ะฐัั ะบ ะฒะพัะพัะฐะผ
rus_verbs:ะณะพัะพะฒะธัััั{}, // ะณะพัะพะฒะธัััั ะบ ะดะพะถะดั
rus_verbs:ัะฑะตะถะฐัั{}, // ัะฑะตะถะฐัั ะบ ะผะฐะผะต
rus_verbs:ะฟะพะดะฝะธะผะฐัั{}, // ะฟะพะดะฝะธะผะฐัั ะบ ะธััะพัะฝะธะบั ัะธะณะฝะฐะปะฐ
rus_verbs:ะพัะพัะปะฐัั{}, // ะพัะพัะปะฐัั ะบ ััะบะพะฒะพะดะธัะตะปั
rus_verbs:ะฟัะธะณะพัะพะฒะธัััั{}, // ะฟัะธะณะพัะพะฒะธัััั ะบ ั
ัะดัะตะผั
rus_verbs:ะฟัะธัััะฟะธัั{}, // ะฟัะธัััะฟะธัั ะบ ะฒัะฟะพะปะฝะตะฝะธั ะพะฑัะทะฐะฝะฝะพััะตะน
rus_verbs:ะผะตัะฝััััั{}, // ะผะตัะฝััััั ะบ ัะพะฝัะฐะฝั
rus_verbs:ะฟัะธัะปััะธะฒะฐัััั{}, // ะฟัะธัะปััะธะฒะฐัััั ะบ ะณะพะปะพัั ัะฐะทัะผะฐ
rus_verbs:ะฟะพะฑัะตััะธ{}, // ะฟะพะฑัะตััะธ ะบ ะฒัั
ะพะดั
rus_verbs:ะผัะฐัััั{}, // ะผัะฐัััั ะบ ััะฟะตั
ั
rus_verbs:ะฝะตััะธัั{}, // ะฝะตััะธัั ะบ ะพะฑััะฒั
rus_verbs:ะฟะพะฟะฐะดะฐัั{}, // ะฟะพะฟะฐะดะฐัั ะบ ั
ะพัะพัะตะผั ะบะพััะพะฟัะฐะฒั
rus_verbs:ะพะฟะพะทะดะฐัั{}, // ะพะฟะพะทะดะฐัั ะบ ะฟัะธั
ะพัะตัะฐะฟะตะฒัั
rus_verbs:ะฟะพััะปะฐัั{}, // ะฟะพััะปะฐัั ะบ ะดะพะบัะพัั
rus_verbs:ะฟะพะฟะปััั{}, // ะฟะพะฟะปััั ะบ ะฑะตัะตะณั
rus_verbs:ะฟะพะดัะพะปะบะฝััั{}, // ะฟะพะดัะพะปะบะฝััั ะบ ะฐะบัะธะฒะฝะพะน ัะฐะฑะพัะต
rus_verbs:ะพัะฝะตััะธ{}, // ะพัะฝะตััะธ ะถะธะฒะพัะฝะพะต ะบ ะฒะตัะตัะธะฝะฐัั
rus_verbs:ะฟัะธัะปะพะฝะธัััั{}, // ะฟัะธัะปะพะฝะธัััั ะบ ััะฒะพะปั
rus_verbs:ะฝะฐะบะปะพะฝะธัั{}, // ะฝะฐะบะปะพะฝะธัั ะบ ะผะธัะบะต ั ะผะพะปะพะบะพะผ
rus_verbs:ะฟัะธะบะพัะฝััััั{}, // ะฟัะธะบะพัะฝััััั ะบ ะฟะพะฒะตัั
ะฝะพััะธ
rus_verbs:ัะฒะตะทัะธ{}, // ัะฒะตะทัะธ ะบ ะฑะฐะฑััะบะต
rus_verbs:ะทะฐะบะฐะฝัะธะฒะฐัััั{}, // ะทะฐะบะฐะฝัะธะฒะฐัััั ะบ ะบะพะฝัั ะฟััะตัะตััะฒะธั
rus_verbs:ะฟะพะดะพะทะฒะฐัั{}, // ะฟะพะดะพะทะฒะฐัั ะบ ัะตะฑะต
rus_verbs:ัะปะตัะตัั{}, // ัะปะตัะตัั ะบ ัะตะฟะปัะผ ะฑะตัะตะณะฐะผ
rus_verbs:ะปะพะถะธัััั{}, // ะปะพะถะธัััั ะบ ะผัะถั
rus_verbs:ัะฑะธัะฐัััั{}, // ัะฑะธัะฐัััั ะบ ัะตััะพะฒะพะน ะฑะฐะฑััะบะต
rus_verbs:ะบะปะฐััั{}, // ะบะปะฐััั ะบ ะดััะณะธะผ ะดะพะบัะผะตะฝัะฐะผ
rus_verbs:ะดะพััะฐะฒะปััั{}, // ะดะพััะฐะฒะปััั ะบ ะฟะพะดัะตะทะดั
rus_verbs:ะฟะพะฒะพัะฐัะธะฒะฐัััั{}, // ะฟะพะฒะพัะฐัะธะฒะฐัััั ะบ ะธััะพัะฝะธะบั ััะผะฐ
rus_verbs:ะทะฐะณะปัะดัะฒะฐัั{}, // ะทะฐะณะปัะดัะฒะฐัั ะบ ะปัะฑะพะฒะฝะธัะต
rus_verbs:ะทะฐะฝะตััะธ{}, // ะทะฐะฝะตััะธ ะบ ะทะฐะบะฐะทัะธะบะฐะผ
rus_verbs:ะฟัะธะฑะตะถะฐัั{}, // ะฟัะธะฑะตะถะฐัั ะบ ะฟะฐะฟะต
rus_verbs:ะฟัะธััะฝััั{}, // ะฟัะธััะฝััั ะบ ะฟัะธัะฐะปั
rus_verbs:ะฟะตัะตะฒะพะดะธัั{}, // ะฟะตัะตะฒะพะดะธัั ะฒ ัััะพะนัะธะฒัั ะบ ะฟะตัะตะณัะตะฒั ัะพัะผั
rus_verbs:ะฟะพะดะฐัั{}, // ะพะฝ ะฟะพะดะฐะป ะปะธะผัะทะธะฝ ะบ ะฟะพะดัะตะทะดั
rus_verbs:ะฟะพะดะฐะฒะฐัั{}, // ะพะฝะฐ ะฟะพะดะฐะฒะฐะปะฐ ัะพัั ะบ ะผััั
rus_verbs:ะฟัะธะพะฑัะฐัััั{}, // ะฟัะธะพะฑัะฐัััั ะบ ะบัะปััััะต
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะตัะฟะพัะพะฑะฝัะน{}, // ะะฐัะฐ ะดะพัะบะฐ ะฝะตัะฟะพัะพะฑะฝะฐ ะบ ััะตะฝะธั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะตะฟัะธัะฟะพัะพะฑะปะตะฝะฝัะน{}, // ะญัะธ ััััะพะนััะฒะฐ ะฝะตะฟัะธัะฟะพัะพะฑะปะตะฝั ะบ ัะฐะฑะพัะต ะฒ ะถะฐัั
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟัะตะดะฝะฐะทะฝะฐัะตะฝะฝัะน{}, // ะกัะฐััะน ะดะพะผ ะฟัะตะดะฝะฐะทะฝะฐัะตะฝ ะบ ัะฝะพัั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒะฝะธะผะฐัะตะปัะฝัะน{}, // ะะฝะฐ ะฒัะตะณะดะฐ ะฒะฝะธะผะฐัะตะปัะฝะฐ ะบ ะณะพัััะผ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐะทะฝะฐัะตะฝะฝัะน{}, // ะะตะปะพ ะฝะฐะทะฝะฐัะตะฝะพ ะบ ะดะพะบะปะฐะดั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฐะทัะตัะตะฝะฝัะน{}, // ะญัะฐ ะบะฝะธะณะฐ ัะฐะทัะตัะตะฝะฐ ะบ ะฟะตัะฐัะธ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะฝะธัั
ะพะดะธัะตะปัะฝัะน{}, // ะญัะพั ััะธัะตะปั ัะฝะธัั
ะพะดะธัะตะปะตะฝ ะบ ััะตะฝะธะบะฐะผ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะณะพัะพะฒัะน{}, // ะฏ ะณะพัะพะฒ ะบ ัะบะทะฐะผะตะฝะฐะผ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ััะตะฑะพะฒะฐัะตะปัะฝัะน{}, // ะะฝ ะพัะตะฝั ััะตะฑะพะฒะฐัะตะปะตะฝ ะบ ัะตะฑะต.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะถะฐะดะฝัะน{}, // ะะฝ ะถะฐะดะตะฝ ะบ ะดะตะฝัะณะฐะผ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะณะปัั
ะพะน{}, // ะะฝ ะณะปัั
ะบ ะผะพะตะน ะฟัะพััะฑะต.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะดะพะฑััะน{}, // ะะฝ ะดะพะฑั ะบ ะดะตััะผ.
rus_verbs:ะฟัะพัะฒะปััั{}, // ะะฝ ะฒัะตะณะดะฐ ะฟัะพัะฒะปัะป ะถะธะฒะพะน ะธะฝัะตัะตั ะบ ะฝะฐัะธะผ ะดะตะปะฐะผ.
rus_verbs:ะฟะปััั{}, // ะะฐัะพั
ะพะด ะฟะปัะป ะบ ะฑะตัะตะณั.
rus_verbs:ะฟะพะนัะธ{}, // ั ะฟะพัะตะป ะบ ะดะพะบัะพัั
rus_verbs:ะฟัะธะดัะธ{}, // ะฟัะธะดัะธ ะบ ะฒัะฒะพะดั
rus_verbs:ะทะฐะณะปัะฝััั{}, // ะฏ ะทะฐะณะปัะฝัะป ะบ ะฒะฐะผ ะผะธะผะพั
ะพะดะพะผ.
rus_verbs:ะฟัะธะฝะฐะดะปะตะถะฐัั{}, // ะญัะพ ัััะตััะฒะพ ะฟัะธะฝะฐะดะปะตะถะธั ะบ ัะฐะทััะดั ัะฐััะตะฝะธะน.
rus_verbs:ะฟะพะดะณะพัะฐะฒะปะธะฒะฐัััั{}, // ะฃัะตะฝะธะบะธ ะฟะพะดะณะพัะฐะฒะปะธะฒะฐัััั ะบ ัะบะทะฐะผะตะฝะฐะผ.
rus_verbs:ัะฟััะบะฐัััั{}, // ะฃะปะธัะฐ ะบัััะพ ัะฟััะบะฐะตััั ะบ ัะตะบะต.
rus_verbs:ัะฟัััะธัััั{}, // ะั ัะฟัััะธะปะธัั ะบ ัะตะบะต.
rus_verbs:ะฟัััะธัั{}, // ะฟััะบะฐัั ะบะพ ะดะฝั
rus_verbs:ะฟัะธะณะพะฒะฐัะธะฒะฐัั{}, // ะั ะฟัะธะณะพะฒะฐัะธะฒะฐะตะผ ัะตะฑั ะบ ะฟะพะถะธะทะฝะตะฝะฝะพะผั ะฒะตัะตะปัั!
rus_verbs:ะพัะพะนัะธ{}, // ะะพะผ ะพัะพััะป ะบ ะฟะปะตะผัะฝะฝะธะบั.
rus_verbs:ะพัั
ะพะดะธัั{}, // ะะพะปั ะพัั
ะพะดะธะป ะบะพ ัะฝั.
rus_verbs:ะฟัะธั
ะพะดะธัั{}, // ะผะตััะฝัะต ะถะธัะตะปะธ ะบ ะฝะตะผั ะฟัะธั
ะพะดะธะปะธ ะปะตัะธัััั
rus_verbs:ะบะธะดะฐัััั{}, // ะฝะต ะบะธะดะฐะนัั ะบ ััะพะปั
rus_verbs:ั
ะพะดะธัั{}, // ะะฝะฐ ะฟัะพัััะดะธะปะฐัั ะธ ัะตะณะพะดะฝั ั
ะพะดะธะปะฐ ะบ ะฒัะฐัั.
rus_verbs:ะทะฐะบะพะฝัะธัััั{}, // ะกะพะฑัะฐะฝะธะต ะทะฐะบะพะฝัะธะปะพัั ะบ ะฒะตัะตัั.
rus_verbs:ะฟะพัะปะฐัั{}, // ะะฝะธ ะฒัะฑัะฐะปะธ ัะฒะพะธั
ะดะตะฟััะฐัะพะฒ ะธ ะฟะพัะปะฐะปะธ ะธั
ะบ ะทะฐะฒะตะดัััะตะผั.
rus_verbs:ะฝะฐะฟัะฐะฒะธัััั{}, // ะั ัะพัะปะธ ะฝะฐ ะฑะตัะตะณ ะธ ะฝะฐะฟัะฐะฒะธะปะธัั ะบ ะณะพัะพะดั.
rus_verbs:ะฝะฐะฟัะฐะฒะปััััั{},
rus_verbs:ัะฒะตััะธัั{}, // ะัั ัะฒะตะปะพัั ะบ ะฝัะปั.
rus_verbs:ะฟัะธัะปะฐัั{}, // ะัะธัะปะธัะต ะบะพะณะพ-ะฝะธะฑัะดั ะบ ะฝะตะน.
rus_verbs:ะฟัะธััะปะฐัั{}, // ะะฝ ะฟัะธััะปะฐะป ะบ ะดะพะปะถะฝะธะบั ัะฒะพะธั
ะณะพะปะพะฒะพัะตะทะพะฒ
rus_verbs:ะฟะพะดะปะตัะตัั{}, // ะกะฐะผะพะปัั ะฟะพะดะปะตัะตะป ะบ ะปะตัั.
rus_verbs:ะฒะพะทะฒัะฐัะฐัััั{}, // ะพะฝ ะฒะพะทะฒัะฐัะฐะตััั ะบ ััะฐัะพะน ัะฐะฑะพัะต
ะณะปะฐะณะพะป:ะฝะฐั
ะพะดะธัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะธะฝัะธะฝะธัะธะฒ:ะฝะฐั
ะพะดะธัััั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, ะดะตะตะฟัะธัะฐััะธะต:ะฝะฐั
ะพะดััั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐั
ะพะดะธะฒัะธะนัั{}, ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะฐั
ะพะดััะธะนัั{}, // ะฏะฟะพะฝะธั ะฝะฐั
ะพะดะธััั ะบ ะฒะพััะพะบั ะพั ะะธัะฐั.
rus_verbs:ะฒะพะทะฒัะฐัะฐัั{}, // ะฒะพะทะฒัะฐัะฐัั ะบ ะถะธะทะฝะธ
rus_verbs:ัะฐัะฟะพะปะฐะณะฐัั{}, // ะัะผะพััะตัะฐ ัะฐัะฟะพะปะฐะณะฐะตั ะบ ัะฐะฑะพัะต.
rus_verbs:ะฒะพะทะฒัะฐัะธัั{}, // ะะพะปะพะบะพะปัะฝัะน ะทะฒะพะฝ ะฒะพะทะฒัะฐัะธะป ะผะตะฝั ะบ ะฟัะพัะปะพะผั.
rus_verbs:ะฟะพัััะฟะธัั{}, // ะ ะฝะฐะผ ะฟะพัััะฟะธะปะฐ ะถะฐะปะพะฑะฐ.
rus_verbs:ะฟะพัััะฟะฐัั{}, // ะ ะฝะฐะผ ะฟะพัััะฟะฐัั ะถะฐะปะพะฑั.
rus_verbs:ะฟััะณะฝััั{}, // ะะตะปะบะฐ ะฟััะณะฝัะปะฐ ะบ ะดะตัะตะฒั
rus_verbs:ัะพัะพะฟะธัััั{}, // ะฟะฐััะฐะถะธัั ัะพัะพะฟัััั ะบ ะฒัั
ะพะดั
rus_verbs:ะฟะพัะพัะพะฟะธัััั{}, // ะฟะพัะพัะพะฟะธัะตัั ะบ ะฒัั
ะพะดั
rus_verbs:ะฒะตัะฝััั{}, // ะฒะตัะฝััั ะบ ะฐะบัะธะฒะฝะพะน ะถะธะทะฝะธ
rus_verbs:ะฟัะธะฟะธัะฐัั{}, // ะฟัะธะฟะธัะฐัั ะบ ััะตะฝะบะต
rus_verbs:ะฟัะพะฒะฐะปะธะฒะฐัั{}, // ะัะพะฒะฐะปะธะฒะฐะน ะบะพ ะฒัะตะผ ัะตัััะผ!
rus_verbs:ะฒะฑะตะถะฐัั{}, // ะะพะปั ะฒะฑะตะถะฐะป ะบะพ ะผะฝะต
rus_verbs:ะฒะฑะตะณะฐัั{}, // ะะพะปั ะฒะฑะตะณะฐะป ะบะพ ะผะฝะต
ะณะปะฐะณะพะป:ะทะฐะฑะตะณะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั }, // ะะพะปั ะทะฐะฑะตะณะฐะป ะบะพ ะผะฝะต
rus_verbs:ะฟะพััััะฐัััั{}, // ะะพะปั ะฟะพััััะฐะปัั ะบะพ ะผะฝะต.
rus_verbs:ะฟะพะฒะตััะธ{}, // ะกะฟัะพัะธะป ั ะพะทะพัะฝะพะณะพ ะะฝัะพะฝะธะพ ะธ ะฟะพะฒะตะป ะตะณะพ ะบ ะดะพะผั
rus_verbs:ะฟะพะฝะตััะธ{}, // ะั ะฟะพะฝะตัะปะธ ะบะพัะฐ ะบ ะฒะตัะตัะธะฝะฐัั
rus_verbs:ะฟัะธะฝะตััะธ{}, // ะฏ ะฟัะธะฝะตั ะบะพัะฐ ะบ ะฒะตัะตัะธะฝะฐัั
rus_verbs:ััััะตะผะธัััั{}, // ะั ััััะตะผะธะปะธัั ะบ ััััั.
rus_verbs:ะฟะพะดะฒะพะดะธัั{}, // ะฃัะธัะตะปั ะฟะพะดะฒะพะดะธะป ะดะตัะตะน ะบ ะฐะบะฒะฐัะธัะผั
rus_verbs:ัะปะตะดะพะฒะฐัั{}, // ะฏ ะฟะพะปััะธะป ะฟัะธะบะฐะท ัะปะตะดะพะฒะฐัั ะบ ะผะตััั ะฝะพะฒะพะณะพ ะฝะฐะทะฝะฐัะตะฝะธั.
rus_verbs:ะฟัะธะณะปะฐัะธัั{}, // ะฏ ะฟัะธะณะปะฐัะธะป ะบ ัะตะฑะต ัะพะฒะฐัะธัะตะน.
rus_verbs:ัะพะฑะธัะฐัััั{}, // ะฏ ัะพะฑะธัะฐััั ะบ ัะตะฑะต ะฒ ะณะพััะธ.
rus_verbs:ัะพะฑัะฐัััั{}, // ะะฐัะฐ ัะพะฑัะฐะปะฐัั ะบ ะดะฐะฝัะธััั
rus_verbs:ัั
ะพะดะธัั{}, // ะฏ ัั
ะพะถั ะบ ะฒัะฐัั.
rus_verbs:ะธะดัะธ{}, // ะะฐัะฐ ัะฒะตัะตะฝะฝะพ ัะปะฐ ะบ ะะตัะต
rus_verbs:ะธะทะผะตะฝะธัััั{}, // ะัะฝะพะฒะฝัะต ะธะฝะดะตะบัั ััะฝะบะฐ ะฐะบัะธะน ะ ะค ะฟะพััะธ ะฝะต ะธะทะผะตะฝะธะปะธัั ะบ ะทะฐะบัััะธั.
rus_verbs:ะพััะณัะฐัั{}, // ะ ะพััะธะนัะบะธะน ััะฝะพะบ ะฐะบัะธะน ะพััะณัะฐะป ะฟะฐะดะตะฝะธะต ะบ ะทะฐะบัััะธั.
rus_verbs:ะทะฐะบะฐะฝัะธะฒะฐัั{}, // ะะฐะบะฐะฝัะธะฒะฐะนัะต ะบ ะพะฑะตะดั
rus_verbs:ะพะฑัะฐัะฐัััั{}, // ะะฑัะฐัะฐะนัะตัั ะบะพ ะผะฝะต ะฒ ะปัะฑะพะต ะฒัะตะผั
rus_verbs:ะพะบะพะฝัะธัั{}, //
rus_verbs:ะดะพะทะฒะพะฝะธัััั{}, // ะฏ ะฝะต ะผะพะณ ะบ ะฒะฐะผ ะดะพะทะฒะพะฝะธัััั.
ะณะปะฐะณะพะป:ะฟัะธะนัะธ{}, ะธะฝัะธะฝะธัะธะฒ:ะฟัะธะนัะธ{}, // ะะฝัะพะฝะธะพ ะฟัะธัะตะป ะบ ะญะปะตะพะฝะพั
rus_verbs:ัะนัะธ{}, // ะะฝัะพะฝะธะพ ััะตะป ะบ ะญะปะตะพะฝะพั
rus_verbs:ะฑะตะถะฐัั{}, // ะะฝัะพะฝะธะพ ะฑะตะถะธั ะบ ะญะปะตะพะฝะพั
rus_verbs:ัะฟะตัะธัั{}, // ะะฝัะพะฝะธะพ ัะฟะตัะธั ะบ ะญะปะตะพะฝะพั
rus_verbs:ัะบะฐะบะฐัั{}, // ะะฝัะพะฝะธะพ ัะบะฐัะตั ะบ ะญะปะตะพะฝะพั
rus_verbs:ะบัะฐััััั{}, // ะะฝัะพะฝะธะพ ะบัะฐะดัััั ะบ ะญะปะตะพะฝะพั
rus_verbs:ะฟะพัะบะฐะบะฐัั{}, // ะฑะตะณะปะตัั ะฟะพัะบะฐะบะฐะปะธ ะบ ั
ะพะปะผะฐะผ
rus_verbs:ะฟะตัะตะนัะธ{} // ะะฝัะพะฝะธะพ ะฟะตัะตัะตะป ะบ ะญะปะตะพะฝะพั
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะ_ะะฐั ะฟัะตะดะปะพะณ:ะบ{} *:*{ ะฟะฐะดะตะถ:ะดะฐั } }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะ_ะะฐั ะฟัะตะดะปะพะณ:ะบ{} @regex("[a-z]+[0-9]*") }
then return true
}
// ะดะปั ะพััะฐะปัะฝัั
ะฟะฐะดะตะถะตะน ะทะฐะฟัะตัะฐะตะผ.
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะบ{} *:*{} }
then return false,-5
}
#endregion ะัะตะดะปะพะณ_ะ
#region ะัะตะดะปะพะณ_ะะะฏ
// ------------------- ะก ะะ ะะะะะะะ 'ะะะฏ' ----------------------
wordentry_set ะะป_ะะะฏ_ะ ะพะด={
ัะฐััะธัะฐ:ะฝะตั{}, // ะดะปั ะผะตะฝั ะฝะตั ะดััะณะธั
ะฟััะตะน.
ัะฐััะธัะฐ:ะฝะตัั{},
rus_verbs:ะะะะะ ะะะขะฌ{}, // ะฟะพะปะธัะธั ะผะพะถะตั ะทะฐะดะตัะถะฐัั ะธั
ะดะปั ะฒัััะฝะตะฝะธั ะฒัะตั
ะพะฑััะพััะตะปัััะฒ ะธ ะดะฐะปัะฝะตะนัะตะณะพ ะพะฟะพะทะฝะฐะฝะธั. (ะะะะะ ะะะขะฌ)
rus_verbs:ะะะะะขะฌะกะฏ{}, // ััะพ ะดะตะปะฐะปะพัั ะดะปั ะปัะดะตะน (ะะะะะขะฌะกะฏ)
rus_verbs:ะพะฑะตัะฝััััั{}, // ะพะฑะตัะฝัะปะฐัั ะดะปั ะณัะตัะตัะบะพะณะพ ััะฝะบะฐ ัััะดะฐ ะฑะฐะฝะบัะพัััะฒะฐะผะธ ะฟัะตะดะฟัะธััะธะน ะธ ะผะฐัััะฐะฑะฝัะผะธ ัะพะบัะฐัะตะฝะธัะผะธ (ะพะฑะตัะฝััััั)
rus_verbs:ะะ ะะะะะะะะงะะขะฌะกะฏ{}, // ะกะบะพัะตะต ะฒัะตะณะพ ััะถะตะปัะน ะบะปะธะฝะพะบ ะฒะพะพะฑัะต ะฝะต ะฟัะตะดะฝะฐะทะฝะฐัะฐะปัั ะดะปั ะฑัะพัะบะพะฒ (ะะ ะะะะะะะะงะะขะฌะกะฏ)
rus_verbs:ะะะะฃะงะะขะฌ{}, // ัั ะผะพะถะตัั ะฟะพะปััะธัั ะตะณะพ ะดะปั ะฝะฐั? (ะะะะฃะงะะขะฌ)
rus_verbs:ะะ ะะะฃะะะขะฌ{}, // ะะฐั ะฑะพัั ัะถะต ะฟัะธะดัะผะฐะป ะดะปั ะฝะฐั ะฒะตัะตะปะตะฝัะบัั ัะผะตััั. (ะะ ะะะฃะะะขะฌ)
rus_verbs:ะพะบะฐะทะฐัััั{}, // ััะพ ะพะบะฐะทะฐะปะพัั ะดะปั ะฝะธั
ััะถะตะปะพะน ะทะฐะดะฐัะตะน
rus_verbs:ะะะะะ ะะขะฌ{}, // ัะตะฟะตัั ะพะฝะฐ ะณะพะฒะพัะธะปะฐ ะดะปั ะฝะฐั ะพะฑะพะธั
(ะะะะะ ะะขะฌ)
rus_verbs:ะะกะะะะะะะขะฌ{}, // ะพัะฒะพะฑะพะดะธัั ะตะต ะดะปั ัะตะฑั? (ะะกะะะะะะะขะฌ)
rus_verbs:ัะฐะฑะพัะฐัั{}, // ะั ัะฐะฑะพัะฐะตะผ ะดะปั ัะตั
, ะบัะพ ัะตะฝะธั ัะดะพะฑััะฒะพ
rus_verbs:ะกะขะะขะฌ{}, // ะบะตะผ ะพะฝะฐ ััะฐะฝะตั ะดะปั ะฝะตะณะพ? (ะกะขะะขะฌ)
rus_verbs:ะฏะะะขะฌะกะฏ{}, // ะฒั ะดะปั ััะพะณะพ ัะฒะธะปะธัั ััะดะฐ? (ะฏะะะขะฌะกะฏ)
rus_verbs:ะะะขะะ ะฏะขะฌ{}, // ะถะธะทะฝั ะฟะพัะตััะปะฐ ะดะปั ะผะตะฝั ะฒััะบะธะน ัะผััะป (ะะะขะะ ะฏะขะฌ)
rus_verbs:ะฃะขะ ะะขะะขะฌ{}, // ะผะพะน ะผะธั ัััะฐัะธะป ะดะปั ะผะตะฝั ะฒััะบะพะต ะฟะพะดะพะฑะธะต ัะผััะปะฐ (ะฃะขะ ะะขะะขะฌ)
rus_verbs:ะะะกะขะะขะฌ{}, // ัั ะดะพะปะถะตะฝ ะดะพััะฐัั ะตะต ะดะปั ะผะตะฝั! (ะะะกะขะะขะฌ)
rus_verbs:ะะ ะะขะฌ{}, // ะฝะตะบะพัะพััะต ะฑะตััั ะดะปั ัะตะฑั (ะะ ะะขะฌ)
rus_verbs:ะะะะขะฌ{}, // ะธะผะตั ะดะปั ะฒะฐั ะฝะพะฒะพััั (ะะะะขะฌ)
rus_verbs:ะะะะขะฌ{}, // ัะตะฑั ะถะดัั ะดะปั ัะฐะทะณะพะฒะพัะฐ (ะะะะขะฌ)
rus_verbs:ะะ ะะะะกะขะฌ{}, // ัะพะฒัะตะผ ะฟัะพะฟะฐะป ะดะปั ะผะธัะฐ (ะะ ะะะะกะขะฌ)
rus_verbs:ะะะะะฏะขะฌ{}, // ะฝะฐั ะฟะพะดะฝัะปะธ ะดะปั ะพั
ะพัั (ะะะะะฏะขะฌ)
rus_verbs:ะะกะขะะะะะะขะฌะกะฏ{}, // ะฒัะตะผั ะพััะฐะฝะพะฒะธะปะพัั ะดะปั ะฝะตะต (ะะกะขะะะะะะขะฌะกะฏ)
rus_verbs:ะะะงะะะะขะฌะกะฏ{}, // ะดะปั ะฝะตะณะพ ะฝะฐัะธะฝะฐะตััั ะฝะพะฒะฐั ะถะธะทะฝั (ะะะงะะะะขะฌะกะฏ)
rus_verbs:ะะะะงะะขะฌะกะฏ{}, // ะบะพะฝัะธะปะธัั ะดะปั ะฝะตะณะพ ััะธ ะธะณัััะบะธ (ะะะะงะะขะฌะกะฏ)
rus_verbs:ะะะกะขะะขะฌ{}, // ะดะปั ะฝะตะณะพ ะฝะฐััะฐะปะพ ะฒัะตะผั ะดะตะนััะฒะพะฒะฐัั (ะะะกะขะะขะฌ)
rus_verbs:ะกะขะ ะะะขะฌ{}, // ะดะปั ะผะพะปะพะดัั
ัััะพะธะปะธ ะฝะพะฒัะน ะดะพะผ (ะกะขะ ะะะขะฌ)
rus_verbs:ะะะฏะขะฌ{}, // ะฒะพะทัะผะธ ะดะปั ะทะฐัะธัั ััะพั ะผะตั (ะะะฏะขะฌ)
rus_verbs:ะะซะฏะกะะะขะฌ{}, // ะฟะพะฟััะฐััั ะฒัััะฝะธัั ะดะปั ะฒะฐั ะฒัั ัะตะฟะพัะบั (ะะซะฏะกะะะขะฌ)
rus_verbs:ะะ ะะะะขะะะะขะฌ{}, // ะดะฐะฒะฐะน ะฟะพะฟัะพะฑัะตะผ ะฟัะธะณะพัะพะฒะธัั ะดะปั ะฝะธั
ัััะฟัะธะท (ะะ ะะะะขะะะะขะฌ)
rus_verbs:ะะะะฅะะะะขะฌ{}, // ะฑะตัะตะณ ะผะพัั ะผะตััะฒัั
ะฟะพะดั
ะพะดะธะป ะดะปั ััะพะณะพ ะธะดะตะฐะปัะฝะพ (ะะะะฅะะะะขะฌ)
rus_verbs:ะะกะขะะขะฌะกะฏ{}, // ะฒะฝะตัะฝะธะน ะฒะธะด ััะธั
ัะฒะฐัะตะน ะพััะฐะปัั ะดะปั ะฝะฐั ะทะฐะณะฐะดะบะพะน (ะะกะขะะขะฌะกะฏ)
rus_verbs:ะะ ะะะะะขะ{}, // ะดะปั ะผะตะฝั ะฟัะธะฒะตะทะปะธ ะฟะธะฒะพ (ะะ ะะะะะขะ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฅะะ ะะะขะะ ะะซะ{}, // ะะปั ะฒัะตะน ัะตััะธัะพัะธะธ ะบัะฐั ั
ะฐัะฐะบัะตัะตะฝ ัะผะตัะตะฝะฝัะน ะบะพะฝัะธะฝะตะฝัะฐะปัะฝัะน ะบะปะธะผะฐั (ะฅะะ ะะะขะะ ะะซะ)
rus_verbs:ะะ ะะะะกะขะ{}, // ะดะปั ะผะตะฝั ะฑะตะปัั ะปะพัะฐะดั ะฟัะธะฒะตะปะธ (ะะ ะะะะกะขะ ะะะฏ)
rus_verbs:ะะะ ะะะขะฌ{}, // ะธั
ะดะตัะถะฐั ะดะปั ััะดะฐ (ะะะ ะะะขะฌ ะะะฏ)
rus_verbs:ะะ ะะะะกะขะะะะขะฌ{}, // ะฒัะตัะฝะฐะผะตั ะฟัะตะดะพััะฐะฒะธะป ะดะปั ะผะธะณัะฐะฝัะพะฒ ะผะตััะฐ ะฟัะพะถะธะฒะฐะฝะธั ะฒ ััะดะต ะฒะพะปะพะณะพะดัะบะธั
ะพะฑัะตะถะธัะธะน (ะะ ะะะะกะขะะะะขะฌ ะะะฏ)
rus_verbs:ะะ ะะะฃะะซะะะขะฌ{}, // ะฟัะธะดัะผัะฒะฐั ะดะปั ััะพะณะพ ัะฐะทะฝะพะพะฑัะฐะทะฝัะต ะฟัะธัะธะฝั (ะะ ะะะฃะะซะะะขะฌ ะะะฏ)
rus_verbs:ะพััะฐะฒะธัั{}, // ะธะปะธ ะฒะพะพะฑัะต ัะตัะธะปะธ ะพััะฐะฒะธัั ะฟะปะฐะฝะตัั ะดะปั ัะตะฑั
rus_verbs:ะพััะฐะฒะปััั{},
rus_verbs:ะะะกะกะขะะะะะะขะฌ{}, // ะบะฐะบ ัั ะผะพะถะตัั ะฒะพัััะฐะฝะพะฒะธัั ััะพ ะดะปั ะผะตะฝั? (ะะะกะกะขะะะะะะขะฌ ะะะฏ)
rus_verbs:ะขะะะฆะะะะขะฌ{}, // ะฐ ะฒั ัะฐะฝัะตะฒะฐะปะธ ะดะปั ะผะตะฝั ัะฐะฝะตั ัะตะผะธ ะฟะพะบััะฒะฐะป (ะขะะะฆะะะะขะฌ ะะะฏ)
rus_verbs:ะะะขะฌ{}, // ัะฒะพะน ะฟัะธะฝั ะดะฐะป ะผะฝะต ััะพ ะดะปั ัะตะฑั! (ะะะขะฌ ะะะฏ)
rus_verbs:ะะะกะะะะฌะะะะะขะฌะกะฏ{}, // ะผัะถัะธะฝะฐ ะธะท ะปะฐะณะตัั ัะตัะธะป ะฒะพัะฟะพะปัะทะพะฒะฐัััั ะดะปั ะฟะตัะตะดะฒะธะถะตะฝะธั ัะตะบะพะน (ะะะกะะะะฌะะะะะขะฌะกะฏ ะะะฏ)
rus_verbs:ะกะะฃะะะขะฌ{}, // ะพะฝะธ ัะปัะถะธะปะธ ะดะปั ัะฐะทะณะพะฒะพัะพะฒ (ะกะะฃะะะขะฌ ะะะฏ)
rus_verbs:ะะกะะะะฌะะะะะขะฌะกะฏ{}, // ะะปั ะฒััะธัะปะตะฝะธั ัะฐะดะธััะฐ ะฟะพัะฐะถะตะฝะธั ัะดะตัะฝัั
ะฒะทััะฒะพะฒ ะธัะฟะพะปัะทัะตััั ัะพัะผัะปะฐ (ะะกะะะะฌะะะะะขะฌะกะฏ ะะะฏ)
rus_verbs:ะะ ะะะะะฏะขะฌะกะฏ{}, // ะัะธะผะตะฝัะตััั ะดะปั ะธะทะณะพัะพะฒะปะตะฝะธั ะฐะปะบะพะณะพะปัะฝัั
ะบะพะบัะตะนะปะตะน (ะะ ะะะะะฏะขะฌะกะฏ ะะะฏ)
rus_verbs:ะกะะะะ ะจะะขะฌะกะฏ{}, // ะะปั ััะพะณะพ ัะพะฒะตััะฐะปัั ัะฟะตัะธะฐะปัะฝัะน ะผะฐะณะธัะตัะบะธะน ะพะฑััะด (ะกะะะะ ะจะะขะฌะกะฏ ะะะฏ)
rus_verbs:ะะ ะะะะะะขะฌ{}, // ะฐ ะทะดะตัั ะฟะพะฟัะพะฑัะตะผ ะฟัะธะผะตะฝะธัั ะตะต ะดะปั ะดััะณะธั
ัะตะปะตะน. (ะะ ะะะะะะขะฌ ะะะฏ)
rus_verbs:ะะะะะะขะฌ{}, // ัั ะฟะพะทะฒะฐะป ะผะตะฝั ะดะปั ะฝะฐััะพััะตะน ัะฐะฑะพัั. (ะะะะะะขะฌ ะะะฏ)
rus_verbs:ะะะงะะขะฌะกะฏ{}, // ะพัะตัะตะดะฝะพะน ะดะตะฝะตะบ ะฝะฐัะฐะปัั ะดะปั ะัะฑะบะธ ะฝะตัะดะฐัะฝะพ (ะะะงะะขะฌะกะฏ ะะะฏ)
rus_verbs:ะะะกะขะะะะขะฌ{}, // ะฒะฐั ะทะดะตัั ะดะปั ะบัะฐัะพัั ะฟะพััะฐะฒะธะปะธ? (ะะะกะขะะะะขะฌ ะะะฏ)
rus_verbs:ัะผะตัะตัั{}, // ะธะปะธ ัะผะตัะปะฐ ะดะปั ะฒััะบะธั
ััะฒััะฒ? (ัะผะตัะตัั ะดะปั)
rus_verbs:ะะซะะ ะะขะฌ{}, // ัั ัะฐะผ ะฒัะฑัะฐะป ะดะปั ัะตะฑั ััะพั ะฟััั. (ะะซะะ ะะขะฌ ะะะฏ)
rus_verbs:ะะขะะะขะะขะฌ{}, // ัะพั ะถะต ะพัะผะตัะธะป ะดะปั ัะตะฑั ะดััะณะพะต. (ะะขะะะขะะขะฌ ะะะฏ)
rus_verbs:ะฃะกะขะ ะะะขะฌ{}, // ะผั ั
ะพัะธะผ ััััะพะธัั ะดะปั ะฝะธั
ัะบะพะปั. (ะฃะกะขะ ะะะขะฌ ะะะฏ)
rus_verbs:ะะซะขะฌ{}, // ั ะผะตะฝั ะตััั ะดะปั ัะตะฑั ัะฐะฑะพัะฐ. (ะะซะขะฌ ะะะฏ)
rus_verbs:ะะซะะขะ{}, // ะดะปั ะฒัะตะณะพ ะฝะฐัะตะณะพ ะฟะพะบะพะปะตะฝะธั ัะฐะบ ะฒััะปะพ. (ะะซะะขะ ะะะฏ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะะะะซะ{}, // ะธะผะตะฝะฝะพ ัะฒะพะต ะผะฝะตะฝะธะต ะดะปั ะฝะฐั ะบัะฐะนะฝะต ะฒะฐะถะฝะพ. (ะะะะะซะ ะะะฏ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะฃะะะซะ{}, // ะดะปั ะปัะฑะพะณะพ ะฟะปะตะผะตะฝะธ ะฝัะถะฝะฐ ะฟัะตะถะดะต ะฒัะตะณะพ ัะธะปะฐ. (ะะฃะะะ ะะะฏ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะะะ ะะะะ{}, // ััะธ ะผะตััะฐ ะฑัะปะธ ะดะพัะพะณะธ ะดะปั ะฝะธั
ะพะฑะพะธั
. (ะะะ ะะะะ ะะะฏ)
rus_verbs:ะะะกะขะฃะะะขะฌ{}, // ัะตะฟะตัั ะดะปั ะฑะพะปััะธั
ะปัะดะตะน ะฝะฐัััะฟะธะปะพ ะฒัะตะผั ะดะตะนััะฒะธะน. (ะะะกะขะฃะะะขะฌ ะะะฏ)
rus_verbs:ะะะะะขะฌ{}, // ััะฐััะน ะฟะตะฝั ะดะฐะฒะฐะป ะดะปั ััะพะณะพ ั
ะพัะพัะธะน ะพะณะพะฝั. (ะะะะะขะฌ ะะะฏ)
rus_verbs:ะะะะะขะฌะกะฏ{}, // ะดะพะฑัะพะต ััะฐัะพะต ะฒัะตะผั ะณะพะดะธััั ะปะธัั ะดะปั ะฒะพัะฟะพะผะธะฝะฐะฝะธะน. (ะะะะะขะฌะกะฏ ะะะฏ)
rus_verbs:ะขะะ ะฏะขะฌ{}, // ะฒัะตะผั ะฟัะพััะพ ัะตััะตั ะดะปั ะฒะฐั ะฒััะบะพะต ะทะฝะฐัะตะฝะธะต. (ะขะะ ะฏะขะฌ ะะะฏ)
rus_verbs:ะะะะะขะฌะกะฏ{}, // ะฝะฐััะฐะปะพ ะฒัะตะผั ะถะตะฝะธัััั ะดะปั ะฟะพะปัะทั ัะฒะพะตะณะพ ะบะปะฐะฝะฐ. (ะะะะะขะฌะกะฏ ะะะฏ)
rus_verbs:ะกะฃะฉะะกะขะะะะะขะฌ{}, // ะฒะตัั ะผะธั ะฟะตัะตััะฐะป ัััะตััะฒะพะฒะฐัั ะดะปั ะฝะธั
ะพะฑะพะธั
. (ะกะฃะฉะะกะขะะะะะขะฌ ะะะฏ)
rus_verbs:ะะะขะฌ{}, // ะถะธัั ะดะปั ัะตะฑั ะธะปะธ ะถะธัั ะดะปั ะฝะธั
. (ะะะขะฌ ะะะฏ)
rus_verbs:ะพัะบัััั{}, // ะดะฒะตัะธ ะผะพะตะณะพ ะดะพะผะฐ ะฒัะตะณะดะฐ ะพัะบัััั ะดะปั ะฒะฐั. (ะะขะะ ะซะขะซะ ะะะฏ)
rus_verbs:ะทะฐะบัััั{}, // ััะพั ะผะธั ะฑัะดะตั ะทะฐะบััั ะดะปั ะฝะธั
. (ะะะะ ะซะขะซะ ะะะฏ)
rus_verbs:ะขะ ะะะะะะขะฌะกะฏ{}, // ะดะปั ััะพะณะพ ััะตะฑัะตััั ะพะณัะพะผะฝะพะต ะบะพะปะธัะตััะฒะพ ัะฝะตัะณะธะธ. (ะขะ ะะะะะะขะฌะกะฏ ะะะฏ)
rus_verbs:ะ ะะะะ ะะะขะฌ{}, // ะะปะตะบัะตะน ัะฐะทะพัะฒะฐะป ะดะปั ััะพะณะพ ัะฒะพั ััะฑะฐั
ั. (ะ ะะะะ ะะะขะฌ ะะะฏ)
rus_verbs:ะะะะะะขะ{}, // ะฒะฟะพะปะฝะต ะฟะพะดะพะนะดะตั ะดะปั ะฝะฐัะฐะปะฐ ะฝะฐัะตะน ัะบัะฟะตะดะธัะธะธ. (ะะะะะะขะ ะะะฏ)
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะพะฟะฐัะฝัะน{}, // ัะธะปัะฝัะน ั
ะพะปะพะด ะพะฟะฐัะตะฝ ะดะปั ะพัะบัััะพะน ัะฐะฝั. (ะะะะกะะ ะะะฏ)
rus_verbs:ะะ ะะะขะ{}, // ะดะปั ะฒะฐั ะฟัะธัะปะพ ะพัะตะฝั ะฒะฐะถะฝะพะต ัะพะพะฑัะตะฝะธะต. (ะะ ะะะขะ ะะะฏ)
rus_verbs:ะฒัะฒะตััะธ{}, // ะผั ัะฟะตัะธะฐะปัะฝะพ ะฒัะฒะตะปะธ ััะธั
ะถะธะฒะพัะฝัั
ะดะปั ะผััะฐ.
rus_verbs:ัะฑัะฐัั{}, // ะ ะฒะฐะณะพะฝะฐั
ะผะตััะพ ะดะปั ะบะพะผัะพััะฐ ะฟะฐััะฐะถะธัะพะฒ ัะฑะตััั ัะธะดะตะฝัั (ะฃะะ ะะขะฌ ะ, ะะะฏ)
rus_verbs:ะพััะฐะฒะฐัััั{}, // ะผะตั
ะฐะฝะธะทะผ ััะพะณะพ ะฒะพะทะดะตะนััะฒะธั ะพััะฐะตััั ะดะปั ะผะตะฝั ะทะฐะณะฐะดะบะพะน. (ะพััะฐะตััั ะดะปั)
rus_verbs:ะฏะะะฏะขะฌะกะฏ{}, // ะงะฐะน ัะฒะปัะตััั ะดะปั ะบะธัะฐะนัะตะฒ ะพะฑััะฝัะผ ะตะถะตะดะฝะตะฒะฝัะผ ะฝะฐะฟะธัะบะพะผ (ะฏะะะฏะขะฌะกะฏ ะะะฏ)
rus_verbs:ะะ ะะะะะฏะขะฌ{}, // ะะปั ะพัะตะฝะพะบ ะฑัะดััะธั
ะธะทะผะตะฝะตะฝะธะน ะบะปะธะผะฐัะฐ ะฟัะธะผะตะฝััั ะผะพะดะตะปะธ ะพะฑัะตะน ัะธัะบัะปััะธะธ ะฐัะผะพััะตัั. (ะะ ะะะะะฏะขะฌ ะะะฏ)
rus_verbs:ะะะะขะะ ะฏะขะฌ{}, // ะฟะพะฒัะพััั ะดะปั ะะตัะธ (ะะะะขะะ ะฏะขะฌ ะะะฏ)
rus_verbs:ะฃะะะขะ ะะะะฏะขะฌ{}, // ะัะฐัะบะธ, ัะฟะพััะตะฑะปัะตะผัะต ะดะปั ะถะธะฒะพะฟะธัะธ (ะฃะะะขะ ะะะะฏะขะฌ ะะะฏ)
rus_verbs:ะะะะกะขะ{}, // ะะปั ะทะปะพััะฝัั
ะฝะฐัััะธัะตะปะตะน ะฟัะตะดะปะพะถะธะปะธ ะฒะฒะตััะธ ะฟะพะฒััะตะฝะฝัะต ัััะฐัั (ะะะะกะขะ ะะะฏ)
rus_verbs:ะฝะฐะนัะธัั{}, // ั ะฒะฐั ะฝะฐะนะดะตััั ะดะปั ะฝะตะณะพ ัะฐะฑะพัะฐ?
rus_verbs:ะทะฐะฝะธะผะฐัััั{}, // ะพะฝะธ ะทะฐะฝะธะผะฐัััั ััะธะผ ะดะปั ัะฐะทะฒะปะตัะตะฝะธั. (ะทะฐะฝะธะผะฐัััั ะดะปั)
rus_verbs:ะทะฐะตั
ะฐัั{}, // ะะพะปั ะทะฐะตั
ะฐะป ะดะปั ะพะฑััะถะดะตะฝะธั ะฟัะพะตะบัะฐ
rus_verbs:ัะพะทัะตัั{}, // ัะพะทัะตัั ะดะปั ะฟะพะฑะตะณะฐ
rus_verbs:ะฝะฐะผะตัะธัั{}, // ะฝะฐะผะตัะธัั ะดะปั ะฟัะพะฒะตัะบะธ
rus_verbs:ัััะฝะธัั{}, // ัััะฝะธัั ะดะปั ัะตะฑั
rus_verbs:ะฝะฐะฝะธะผะฐัั{}, // ะฝะฐะฝะธะผะฐัั ะดะปั ัะฐะทะพะฒะพะน ัะฐะฑะพัั
rus_verbs:ะฟัะธัะฟะพัะพะฑะธัั{}, // ะฟัะธัะฟะพัะพะฑะธัั ะดะปั ัะดะพะฒะพะปัััะฒะธั
rus_verbs:ะพะฑะปัะฑะพะฒะฐัั{}, // ะพะฑะปัะฑะพะฒะฐัั ะดะปั ะฟะพัะธะดะตะปะพะบ
rus_verbs:ะฟัะพััะฝะธัั{}, // ะฟัะพััะฝะธัั ะดะปั ัะตะฑั
rus_verbs:ะทะฐะดะตะนััะฒะพะฒะฐัั{}, // ะทะฐะดะตะนััะฒะพะฒะฐัั ะดะปั ะฟะฐัััะปะธัะพะฒะฐะฝะธั
rus_verbs:ะฟัะธะณะพัะพะฒะปััั{}, // ะฟัะธะณะพัะพะฒะปััั ะดะปั ะฟัะพะฒะตัะบะธ
ะธะฝัะธะฝะธัะธะฒ:ะธัะฟะพะปัะทะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั }, // ะธัะฟะพะปัะทะพะฒะฐัั ะดะปั ะดะพััะธะถะตะฝะธั ัะตะปะธ
ะธะฝัะธะฝะธัะธะฒ:ะธัะฟะพะปัะทะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะณะปะฐะณะพะป:ะธัะฟะพะปัะทะพะฒะฐัั{ ะฒะธะด:ัะพะฒะตัั },
ะณะปะฐะณะพะป:ะธัะฟะพะปัะทะพะฒะฐัั{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะธัะฟะพะปัะทะพะฒะฐะฝะฝัะน{},
ะดะตะตะฟัะธัะฐััะธะต:ะธัะฟะพะปัะทัั{},
ะดะตะตะฟัะธัะฐััะธะต:ะธัะฟะพะปัะทะพะฒะฐะฒ{},
rus_verbs:ะฝะฐะฟัััััั{}, // ะฝะฐะฟัััััั ะดะปั ัะตัะธัะตะปัะฝะพะณะพ ััะฒะบะฐ
rus_verbs:ะพะดะพะฑัะธัั{}, // ะพะดะพะฑัะธัั ะดะปั ะธัะฟะพะปัะทะพะฒะฐะฝะธั
rus_verbs:ะพะดะพะฑัััั{}, // ะพะดะพะฑัััั ะดะปั ะธัะฟะพะปัะทะพะฒะฐะฝะธั
rus_verbs:ะฟัะธะณะพะดะธัััั{}, // ะฟัะธะณะพะดะธัััั ะดะปั ัะตััะธัะพะฒะฐะฝะธั
rus_verbs:ะณะพัะพะฒะธัั{}, // ะณะพัะพะฒะธัั ะดะปั ะฒัั
ะพะดะฐ ะฒ ัะฒะตั
rus_verbs:ะพัะพะฑัะฐัั{}, // ะพัะพะฑัะฐัั ะดะปั ััะฐััะธั ะฒ ะบะพะฝะบัััะต
rus_verbs:ะฟะพััะตะฑะพะฒะฐัััั{}, // ะฟะพััะตะฑะพะฒะฐัััั ะดะปั ะฟะพะดัะฒะตัะถะดะตะฝะธั
rus_verbs:ะฟะพััะฝะธัั{}, // ะฟะพััะฝะธัั ะดะปั ัะปััะฐัะตะปะตะน
rus_verbs:ะฟะพััะฝััั{}, // ะฟะพััะฝะธัั ะดะปั ัะบะทะฐะผะตะฝะฐัะพัะพะฒ
rus_verbs:ะฟะพะฝะฐะดะพะฑะธัััั{}, // ะฟะพะฝะฐะดะพะฑะธัััั ะดะปั ะพะฑะพัะฝะพะฒะฐะฝะธั
ะธะฝัะธะฝะธัะธะฒ:ะฐะดะฐะฟัะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั}, // ะผะฐัะธะฝะฐ ะฑัะปะฐ ะฐะดะฐะฟัะธัะพะฒะฐะฝะฐ ะดะปั ััะปะพะฒะธะน ะบัะฐะนะฝะตะณะพ ัะตะฒะตัะฐ
ะธะฝัะธะฝะธัะธะฒ:ะฐะดะฐะฟัะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฐะดะฐะฟัะธัะพะฒะฐัั{ะฒะธะด:ะฝะตัะพะฒะตัั},
ะณะปะฐะณะพะป:ะฐะดะฐะฟัะธัะพะฒะฐัั{ะฒะธะด:ัะพะฒะตัั},
ะดะตะตะฟัะธัะฐััะธะต:ะฐะดะฐะฟัะธัะพะฒะฐะฒ{},
ะดะตะตะฟัะธัะฐััะธะต:ะฐะดะฐะฟัะธััั{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธััััะธะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธัะพะฒะฐะฒัะธะน{ ะฒะธะด:ัะพะฒะตัั },
//+ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธัะพะฒะฐะฒัะธะน{ ะฒะธะด:ะฝะตัะพะฒะตัั },
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฐะดะฐะฟัะธัะพะฒะฐะฝะฝัะน{},
rus_verbs:ะฝะฐะนัะธ{}, // ะะฐะฟะฐ ะฝะฐัะตะป ะดะปั ะดะตัะตะน ะฝัะฝั
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฒัะตะดะฝัะน{}, // ะญัะพ ะฒัะตะดะฝะพ ะดะปั ะทะดะพัะพะฒัั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฟะพะปะตะทะฝัะน{}, // ะัะพะณัะปะบะธ ะฟะพะปะตะทะฝั ะดะปั ะทะดะพัะพะฒัั.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะพะฑัะทะฐัะตะปัะฝัะน{}, // ะญัะพั ะฟัะฝะบั ะพะฑัะทะฐัะตะปะตะฝ ะดะปั ะธัะฟะพะปะฝะตะฝะธั
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฑะตัะฟะพะปะตะทะฝัะน{}, // ะญัะพ ะปะตะบะฐัััะฒะพ ะฑะตัะฟะพะปะตะทะฝะพ ะดะปั ะฝะตะณะพ
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะตะพะฑั
ะพะดะธะผัะน{}, // ะญัะพ ะปะตะบะฐัััะฒะพ ะฝะตะพะฑั
ะพะดะธะผะพ ะดะปั ะฒัะทะดะพัะพะฒะปะตะฝะธั
rus_verbs:ัะพะทะดะฐัั{}, // ะะฝ ะฝะต ัะพะทะดะฐะฝ ะดะปั ััะพะณะพ ะดะตะปะฐ.
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะปะพะถะฝัะน{}, // ะทะฐะดะฐัะฐ ัะปะพะถะฝะฐ ะดะปั ะผะปะฐะดัะธั
ัะบะพะปัะฝะธะบะพะฒ
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะฝะตัะปะพะถะฝัะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ะปัะณะบะธะน{},
ะฟัะธะปะฐะณะฐัะตะปัะฝะพะต:ัะปะพะถะฝะพะฒะฐััะน{},
rus_verbs:ััะฐะฝะพะฒะธัััั{},
rus_verbs:ะฟัะตะดััะฐะฒะปััั{}, // ะญัะพ ะฝะต ะฟัะตะดััะฐะฒะปัะตั ะดะปั ะผะตะฝั ะธะฝัะตัะตัะฐ.
rus_verbs:ะทะฝะฐัะธัั{}, // ะฏ ัะพั ะฒ ะดะตัะตะฒะฝะต ะธ ั
ะพัะพัะพ ะทะฝะฐะป, ััะพ ะดะปั ะดะตัะตะฒะตะฝัะบะพะน ะถะธะทะฝะธ ะทะฝะฐัะฐั ะฟััะด ะธะปะธ ัะตัะบะฐ
rus_verbs:ะฟัะพะนัะธ{}, // ะะตะฝั ะฟัะพััะป ัะฟะพะบะพะนะฝะพ ะดะปั ะฝะตะณะพ.
rus_verbs:ะฟัะพั
ะพะดะธัั{},
rus_verbs:ะฒััะฐะดะธัััั{}, // ะฑะพะปััะพะน ะทะปะพะน ะฟะธัะฐั ะธ ะตะณะพ ะพััะฐัะฝะฝัะต ะฟะพะผะพัะฝะธะบะธ ะฒััะฐะดะธะปะธัั ะฝะฐ ะฝะตะพะฑะธัะฐะตะผะพะผ ะพัััะพะฒะต ะดะปั ะฟะพะธัะบะฐ ะทะฐััััั
ัะพะบัะพะฒะธั
rus_verbs:ะฒััะฐะถะธะฒะฐัััั{},
rus_verbs:ะฟัะธะฑะฐะฒะปััั{}, // ะะฝ ะปัะฑะธั ะฟัะธะฑะฐะฒะปััั ะดะปั ะบัะฐัะฝะพะณะพ ัะปะพะฒัะฐ.
rus_verbs:ะฟัะธะฑะฐะฒะธัั{},
rus_verbs:ัะพััะฐะฒะธัั{}, // ะ ัะด ััะธะณะพะฝะพะผะตััะธัะตัะบะธั
ัะฐะฑะปะธั ะฑัะป ัะพััะฐะฒะปะตะฝ ะดะปั ะฐัััะพะฝะพะผะธัะตัะบะธั
ัะฐััััะพะฒ.
rus_verbs:ัะพััะฐะฒะปััั{},
rus_verbs:ััะฐัะฐัััั{}, // ะฏ ััะฐัะฐะปัั ะดะปั ะฒะฐั
rus_verbs:ะฟะพััะฐัะฐัััั{}, // ะฏ ะฟะพััะฐัะฐะปัั ะดะปั ะฒะฐั
rus_verbs:ัะพั
ัะฐะฝะธัััั{}, // ะกัะฐัะธะบ ั
ะพัะพัะพ ัะพั
ัะฐะฝะธะปัั ะดะปั ัะฒะพะตะณะพ ะฒะพะทัะฐััะฐ.
rus_verbs:ัะพะฑัะฐัััั{}, // ัะพะฑัะฐัััั ะดะปั ะพะฑััะถะดะตะฝะธั
rus_verbs:ัะพะฑะธัะฐัััั{}, // ัะพะฑะธัะฐัััั ะดะปั ะพะฑััะถะดะตะฝะธั
rus_verbs:ัะฟะพะปะฝะพะผะพัะธะฒะฐัั{},
rus_verbs:ัะฟะพะปะฝะพะผะพัะธัั{}, // ะตะณะพ ัะฟะพะปะฝะพะผะพัะธะปะธ ะดะปั ะฒะตะดะตะฝะธั ะฟะตัะตะณะพะฒะพัะพะฒ
rus_verbs:ะฟัะธะฝะตััะธ{}, // ะฏ ะฟัะธะฝัั ััั ะบะฝะธะณั ะดะปั ะฒะฐั.
rus_verbs:ะดะตะปะฐัั{}, // ะฏ ััะพ ะดะตะปะฐั ะดะปั ัะดะพะฒะพะปัััะฒะธั.
rus_verbs:ัะดะตะปะฐัั{}, // ะฏ ัะดะตะปะฐั ััะพ ะดะปั ัะดะพะฒะพะปัััะฒะธั.
rus_verbs:ะฟะพะดะณะพัะพะฒะธัั{}, // ั ะฟะพะดะณะพัะพะฒะธะป ะดะปั ะดััะทะตะน ัััะฟัะธะท
rus_verbs:ะฟะพะดะณะพัะฐะฒะปะธะฒะฐัั{}, // ั ะฟะพะดะณะพัะฐะฒะปะธะฒะฐั ะดะปั ะณะพััะตะน ะฝะพะฒัะน ัััะฟัะธะท
rus_verbs:ะทะฐะบัะฟะธัั{}, // ะ ัะบะพะฒะพะดััะฒะพ ัะฐะนะพะฝะฐ ะพะฑะตัะฐะปะพ ะทะฐะบัะฟะธัั ะฝะพะฒัะต ะบะพะผะฑะฐะนะฝั ะดะปั ะฝะฐัะตะณะพ ัะตะปะฐ
rus_verbs:ะบัะฟะธัั{}, // ะ ัะบะพะฒะพะดััะฒะพ ัะฐะนะพะฝะฐ ะพะฑะตัะฐะปะพ ะบัะฟะธัั ะฝะพะฒัะต ะบะพะผะฑะฐะนะฝั ะดะปั ะฝะฐัะตะณะพ ัะตะปะฐ
rus_verbs:ะฟัะธะฑััั{} // ะพะฝะธ ะฟัะธะฑัะปะธ ะดะปั ััะฐััะธั
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะะฏ_ะ ะพะด ะฟัะตะดะปะพะณ:ะดะปั{} *:*{ ะฟะฐะดะตะถ:ัะพะด } }
then return true
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะป_ะะะฏ_ะ ะพะด ะฟัะตะดะปะพะณ:ะดะปั{} @regex("[a-z]+[0-9]*") }
then return true
}
// ะดะปั ะพััะฐะปัะฝัั
ะฟะฐะดะตะถะตะน ะทะฐะฟัะตัะฐะตะผ.
fact ะณะป_ะฟัะตะดะป
{
if context { * ะฟัะตะดะปะพะณ:ะดะปั{} *:*{} }
then return false,-4
}
#endregion ะัะตะดะปะพะณ_ะะะฏ
#region ะัะตะดะปะพะณ_ะะข
// ะฟะพะฟัะพะฑัะตะผ ะธะฝัั ัััะฐัะตะณะธั - ะทะฐะฟัะตัะธัั ัะฒัะทัะฒะฐะฝะธะต ั ะะข ะดะปั ะพัะดะตะปัะฝัั
ะณะปะฐะณะพะปะพะฒ, ัะฐะทัะตัะธะฒ ะดะปั ะฒัะตั
ะพััะฐะปัะฝัั
.
wordentry_set ะะปะฐะณ_ะะข_ะ ะพะด_ะะฐะฟั=
{
rus_verbs:ะฝะฐัะปะฐะถะดะฐัััั{}, // ัะฒะพะฑะพะดะพะน ะพั ะพะฑัะทะฐัะตะปัััะฒ
rus_verbs:ะฝะฐัะปะฐะดะธัััั{},
rus_verbs:ะผะพัั{}, // ะะฝ ะฝะต ะผะพะณ ัะดะตัะถะฐัััั ะพั ัะผะตั
ะฐ.
// rus_verbs:ั
ะพัะตัั{},
rus_verbs:ะถะตะปะฐัั{},
rus_verbs:ััะฒััะฒะพะฒะฐัั{}, // ะฒัะต ะฒัะตะผั ะพั ะฒัะตะผะตะฝะธ ััะฒััะฒััั ะตะณะพ.
rus_verbs:ะฟะปะฐะฝะธัะพะฒะฐัั{},
rus_verbs:ะฟัะธะฝััััั{} // ะผั ะฟัะธะฝัะปะธัั ะพะฑะฝะธะผะฐัััั ะพั ัะฐะดะพััะธ.
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะปะฐะณ_ะะข_ะ ะพะด_ะะฐะฟั ะฟัะตะดะปะพะณ:ะพั{} * }
then return false
}
#endregion ะัะตะดะปะพะณ_ะะข
#region ะัะตะดะปะพะณ_ะะะ
/*
// ะทะฐะฟัะตัะธัั ัะฒัะทัะฒะฐะฝะธะต ั ะะะ ะดะปั ะพัะดะตะปัะฝัั
ะณะปะฐะณะพะปะพะฒ, ัะฐะทัะตัะธะฒ ะดะปั ะฒัะตั
ะพััะฐะปัะฝัั
.
wordentry_set ะะปะฐะณ_ะะะ_ะ ะพะด_ะะฐะฟั=
{
rus_verbs:ะผะพัั{}, // ะะฝ ะผะพะณ ัะธัะฐัั ัะฐัะฐะผะธ ะฑะตะท ะพัะดัั
ะฐ.
rus_verbs:ั
ะพัะตัั{},
rus_verbs:ะถะตะปะฐัั{},
rus_verbs:ะฟะปะฐะฝะธัะพะฒะฐัั{},
rus_verbs:ะฟัะธะฝััััั{}
}
fact ะณะป_ะฟัะตะดะป
{
if context { ะะปะฐะณ_ะะะ_ะ ะพะด_ะะฐะฟั ะฟัะตะดะปะพะณ:ะฑะตะท{} * }
then return false
}
*/
#endregion ะัะตะดะปะพะณ_ะะะ
#region ะัะตะดะปะพะณ_ะะ ะะะ
fact ะณะป_ะฟัะตะดะป
{
if context { * ะัะตะดะปะพะณะะปัะัะต * }
then return false,-5
}
#endregion ะัะตะดะปะพะณ_ะะ ะะะ
// ------------------------------------
// ะะพ ัะผะพะปัะฐะฝะธั ัะฐะทัะตัะฐะตะผ ะฒัะต ะพััะฐะปัะฝัะต ัะพัะตัะฐะฝะธั.
fact ะณะป_ะฟัะตะดะป
{
if context { * * * }
then return true
}
| ัะพะพััะดะธัั ะฒ ะณะฐัะฐะถะต
| rus_verbs:ัะพะพััะดะธัั{}, | 5,481,363 | [
1,
146,
228,
145,
127,
145,
127,
146,
227,
146,
230,
145,
117,
145,
121,
146,
229,
146,
239,
225,
145,
115,
225,
145,
116,
145,
113,
146,
227,
145,
113,
145,
119,
145,
118,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
436,
407,
67,
502,
2038,
30,
146,
228,
145,
127,
145,
127,
146,
227,
146,
230,
145,
117,
145,
121,
146,
229,
146,
239,
2916,
16,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: AGPL-3.0-only
/*
Pricing.sol - SKALE Manager
Copyright (C) 2018-Present SKALE Labs
@author Artem Payvin
@author Vadim Yavorsky
SKALE Manager is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity 0.8.11;
import "@skalenetwork/skale-manager-interfaces/IPricing.sol";
import "@skalenetwork/skale-manager-interfaces/ISchainsInternal.sol";
import "@skalenetwork/skale-manager-interfaces/INodes.sol";
import "./Permissions.sol";
import "./ConstantsHolder.sol";
/**
* @title Pricing
* @dev Contains pricing operations for SKALE network.
*/
contract Pricing is Permissions, IPricing {
uint public constant INITIAL_PRICE = 5 * 10**6;
uint public price;
uint public totalNodes;
uint public lastUpdated;
function initNodes() external override {
INodes nodes = INodes(contractManager.getContract("Nodes"));
totalNodes = nodes.getNumberOnlineNodes();
}
/**
* @dev Adjust the schain price based on network capacity and demand.
*
* Requirements:
*
* - Cooldown time has exceeded.
*/
function adjustPrice() external override {
ConstantsHolder constantsHolder = ConstantsHolder(contractManager.getContract("ConstantsHolder"));
require(
block.timestamp > lastUpdated + constantsHolder.COOLDOWN_TIME(),
"It's not a time to update a price"
);
checkAllNodes();
uint load = _getTotalLoad();
uint capacity = _getTotalCapacity();
bool networkIsOverloaded = load * 100 > constantsHolder.OPTIMAL_LOAD_PERCENTAGE() * capacity;
uint loadDiff;
if (networkIsOverloaded) {
loadDiff = load * 100 - constantsHolder.OPTIMAL_LOAD_PERCENTAGE() * capacity;
} else {
loadDiff = constantsHolder.OPTIMAL_LOAD_PERCENTAGE() * capacity - load * 100;
}
uint priceChangeSpeedMultipliedByCapacityAndMinPrice =
constantsHolder.ADJUSTMENT_SPEED() * loadDiff * price;
uint timeSkipped = block.timestamp - lastUpdated;
uint priceChange = priceChangeSpeedMultipliedByCapacityAndMinPrice
* timeSkipped
/ constantsHolder.COOLDOWN_TIME()
/ capacity
/ constantsHolder.MIN_PRICE();
if (networkIsOverloaded) {
assert(priceChange > 0);
price = price + priceChange;
} else {
if (priceChange > price) {
price = constantsHolder.MIN_PRICE();
} else {
price = price - priceChange;
if (price < constantsHolder.MIN_PRICE()) {
price = constantsHolder.MIN_PRICE();
}
}
}
lastUpdated = block.timestamp;
}
/**
* @dev Returns the total load percentage.
*/
function getTotalLoadPercentage() external view override returns (uint) {
return _getTotalLoad() * 100 / _getTotalCapacity();
}
function initialize(address newContractsAddress) public override initializer {
Permissions.initialize(newContractsAddress);
lastUpdated = block.timestamp;
price = INITIAL_PRICE;
}
function checkAllNodes() public override {
INodes nodes = INodes(contractManager.getContract("Nodes"));
uint numberOfActiveNodes = nodes.getNumberOnlineNodes();
require(totalNodes != numberOfActiveNodes, "No changes to node supply");
totalNodes = numberOfActiveNodes;
}
function _getTotalLoad() private view returns (uint) {
ISchainsInternal schainsInternal = ISchainsInternal(contractManager.getContract("SchainsInternal"));
uint load = 0;
uint numberOfSchains = schainsInternal.numberOfSchains();
for (uint i = 0; i < numberOfSchains; i++) {
bytes32 schain = schainsInternal.schainsAtSystem(i);
uint numberOfNodesInSchain = schainsInternal.getNumberOfNodesInGroup(schain);
uint part = schainsInternal.getSchainsPartOfNode(schain);
load = load + numberOfNodesInSchain * part;
}
return load;
}
function _getTotalCapacity() private view returns (uint) {
INodes nodes = INodes(contractManager.getContract("Nodes"));
ConstantsHolder constantsHolder = ConstantsHolder(contractManager.getContract("ConstantsHolder"));
return nodes.getNumberOnlineNodes() * constantsHolder.TOTAL_SPACE_ON_NODE();
}
}
// SPDX-License-Identifier: AGPL-3.0-only
/*
IPricing.sol - SKALE Manager
Copyright (C) 2018-Present SKALE Labs
@author Artem Payvin
SKALE Manager is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.10 <0.9.0;
interface IPricing {
function initNodes() external;
function adjustPrice() external;
function checkAllNodes() external;
function getTotalLoadPercentage() external view returns (uint);
}
// SPDX-License-Identifier: AGPL-3.0-only
/*
ISchainsInternal - SKALE Manager Interfaces
Copyright (C) 2021-Present SKALE Labs
@author Dmytro Stebaeiv
SKALE Manager Interfaces is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager Interfaces is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager Interfaces. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.10 <0.9.0;
interface ISchainsInternal {
struct Schain {
string name;
address owner;
uint indexInOwnerList;
uint8 partOfNode;
uint lifetime;
uint startDate;
uint startBlock;
uint deposit;
uint64 index;
uint generation;
address originator;
}
struct SchainType {
uint8 partOfNode;
uint numberOfNodes;
}
/**
* @dev Emitted when schain type added.
*/
event SchainTypeAdded(uint indexed schainType, uint partOfNode, uint numberOfNodes);
/**
* @dev Emitted when schain type removed.
*/
event SchainTypeRemoved(uint indexed schainType);
function initializeSchain(
string calldata name,
address from,
address originator,
uint lifetime,
uint deposit) external;
function createGroupForSchain(
bytes32 schainHash,
uint numberOfNodes,
uint8 partOfNode
)
external
returns (uint[] memory);
function changeLifetime(bytes32 schainHash, uint lifetime, uint deposit) external;
function removeSchain(bytes32 schainHash, address from) external;
function removeNodeFromSchain(uint nodeIndex, bytes32 schainHash) external;
function deleteGroup(bytes32 schainHash) external;
function setException(bytes32 schainHash, uint nodeIndex) external;
function setNodeInGroup(bytes32 schainHash, uint nodeIndex) external;
function removeHolesForSchain(bytes32 schainHash) external;
function addSchainType(uint8 partOfNode, uint numberOfNodes) external;
function removeSchainType(uint typeOfSchain) external;
function setNumberOfSchainTypes(uint newNumberOfSchainTypes) external;
function removeNodeFromAllExceptionSchains(uint nodeIndex) external;
function removeAllNodesFromSchainExceptions(bytes32 schainHash) external;
function makeSchainNodesInvisible(bytes32 schainHash) external;
function makeSchainNodesVisible(bytes32 schainHash) external;
function newGeneration() external;
function addSchainForNode(uint nodeIndex, bytes32 schainHash) external;
function removeSchainForNode(uint nodeIndex, uint schainIndex) external;
function removeNodeFromExceptions(bytes32 schainHash, uint nodeIndex) external;
function isSchainActive(bytes32 schainHash) external view returns (bool);
function schainsAtSystem(uint index) external view returns (bytes32);
function numberOfSchains() external view returns (uint64);
function getSchains() external view returns (bytes32[] memory);
function getSchainsPartOfNode(bytes32 schainHash) external view returns (uint8);
function getSchainListSize(address from) external view returns (uint);
function getSchainHashesByAddress(address from) external view returns (bytes32[] memory);
function getSchainIdsByAddress(address from) external view returns (bytes32[] memory);
function getSchainHashesForNode(uint nodeIndex) external view returns (bytes32[] memory);
function getSchainIdsForNode(uint nodeIndex) external view returns (bytes32[] memory);
function getSchainOwner(bytes32 schainHash) external view returns (address);
function getSchainOriginator(bytes32 schainHash) external view returns (address);
function isSchainNameAvailable(string calldata name) external view returns (bool);
function isTimeExpired(bytes32 schainHash) external view returns (bool);
function isOwnerAddress(address from, bytes32 schainId) external view returns (bool);
function getSchainName(bytes32 schainHash) external view returns (string memory);
function getActiveSchain(uint nodeIndex) external view returns (bytes32);
function getActiveSchains(uint nodeIndex) external view returns (bytes32[] memory activeSchains);
function getNumberOfNodesInGroup(bytes32 schainHash) external view returns (uint);
function getNodesInGroup(bytes32 schainHash) external view returns (uint[] memory);
function isNodeAddressesInGroup(bytes32 schainId, address sender) external view returns (bool);
function getNodeIndexInGroup(bytes32 schainHash, uint nodeId) external view returns (uint);
function isAnyFreeNode(bytes32 schainHash) external view returns (bool);
function checkException(bytes32 schainHash, uint nodeIndex) external view returns (bool);
function checkHoleForSchain(bytes32 schainHash, uint indexOfNode) external view returns (bool);
function checkSchainOnNode(uint nodeIndex, bytes32 schainHash) external view returns (bool);
function getSchainType(uint typeOfSchain) external view returns(uint8, uint);
function getGeneration(bytes32 schainHash) external view returns (uint);
function isSchainExist(bytes32 schainHash) external view returns (bool);
}
// SPDX-License-Identifier: AGPL-3.0-only
/*
INodes.sol - SKALE Manager
Copyright (C) 2018-Present SKALE Labs
@author Artem Payvin
SKALE Manager is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.10 <0.9.0;
import "./utils/IRandom.sol";
interface INodes {
// All Nodes states
enum NodeStatus {Active, Leaving, Left, In_Maintenance}
struct Node {
string name;
bytes4 ip;
bytes4 publicIP;
uint16 port;
bytes32[2] publicKey;
uint startBlock;
uint lastRewardDate;
uint finishTime;
NodeStatus status;
uint validatorId;
}
// struct to note which Nodes and which number of Nodes owned by user
struct CreatedNodes {
mapping (uint => bool) isNodeExist;
uint numberOfNodes;
}
struct SpaceManaging {
uint8 freeSpace;
uint indexInSpaceMap;
}
struct NodeCreationParams {
string name;
bytes4 ip;
bytes4 publicIp;
uint16 port;
bytes32[2] publicKey;
uint16 nonce;
string domainName;
}
/**
* @dev Emitted when a node is created.
*/
event NodeCreated(
uint nodeIndex,
address owner,
string name,
bytes4 ip,
bytes4 publicIP,
uint16 port,
uint16 nonce,
string domainName
);
/**
* @dev Emitted when a node completes a network exit.
*/
event ExitCompleted(
uint nodeIndex
);
/**
* @dev Emitted when a node begins to exit from the network.
*/
event ExitInitialized(
uint nodeIndex,
uint startLeavingPeriod
);
/**
* @dev Emitted when a node set to in compliant or compliant.
*/
event IncompliantNode(
uint indexed nodeIndex,
bool status
);
/**
* @dev Emitted when a node set to in maintenance or from in maintenance.
*/
event MaintenanceNode(
uint indexed nodeIndex,
bool status
);
/**
* @dev Emitted when a node status changed.
*/
event IPChanged(
uint indexed nodeIndex,
bytes4 previousIP,
bytes4 newIP
);
function removeSpaceFromNode(uint nodeIndex, uint8 space) external returns (bool);
function addSpaceToNode(uint nodeIndex, uint8 space) external;
function changeNodeLastRewardDate(uint nodeIndex) external;
function changeNodeFinishTime(uint nodeIndex, uint time) external;
function createNode(address from, NodeCreationParams calldata params) external;
function initExit(uint nodeIndex) external;
function completeExit(uint nodeIndex) external returns (bool);
function deleteNodeForValidator(uint validatorId, uint nodeIndex) external;
function checkPossibilityCreatingNode(address nodeAddress) external;
function checkPossibilityToMaintainNode(uint validatorId, uint nodeIndex) external returns (bool);
function setNodeInMaintenance(uint nodeIndex) external;
function removeNodeFromInMaintenance(uint nodeIndex) external;
function setNodeIncompliant(uint nodeIndex) external;
function setNodeCompliant(uint nodeIndex) external;
function setDomainName(uint nodeIndex, string memory domainName) external;
function makeNodeVisible(uint nodeIndex) external;
function makeNodeInvisible(uint nodeIndex) external;
function changeIP(uint nodeIndex, bytes4 newIP, bytes4 newPublicIP) external;
function numberOfActiveNodes() external view returns (uint);
function incompliant(uint nodeIndex) external view returns (bool);
function getRandomNodeWithFreeSpace(
uint8 freeSpace,
IRandom.RandomGenerator memory randomGenerator
)
external
view
returns (uint);
function isTimeForReward(uint nodeIndex) external view returns (bool);
function getNodeIP(uint nodeIndex) external view returns (bytes4);
function getNodeDomainName(uint nodeIndex) external view returns (string memory);
function getNodePort(uint nodeIndex) external view returns (uint16);
function getNodePublicKey(uint nodeIndex) external view returns (bytes32[2] memory);
function getNodeAddress(uint nodeIndex) external view returns (address);
function getNodeFinishTime(uint nodeIndex) external view returns (uint);
function isNodeLeft(uint nodeIndex) external view returns (bool);
function isNodeInMaintenance(uint nodeIndex) external view returns (bool);
function getNodeLastRewardDate(uint nodeIndex) external view returns (uint);
function getNodeNextRewardDate(uint nodeIndex) external view returns (uint);
function getNumberOfNodes() external view returns (uint);
function getNumberOnlineNodes() external view returns (uint);
function getActiveNodeIds() external view returns (uint[] memory activeNodeIds);
function getNodeStatus(uint nodeIndex) external view returns (NodeStatus);
function getValidatorNodeIndexes(uint validatorId) external view returns (uint[] memory);
function countNodesWithFreeSpace(uint8 freeSpace) external view returns (uint count);
function getValidatorId(uint nodeIndex) external view returns (uint);
function isNodeExist(address from, uint nodeIndex) external view returns (bool);
function isNodeActive(uint nodeIndex) external view returns (bool);
function isNodeLeaving(uint nodeIndex) external view returns (bool);
}
// SPDX-License-Identifier: AGPL-3.0-only
/*
Permissions.sol - SKALE Manager
Copyright (C) 2018-Present SKALE Labs
@author Artem Payvin
SKALE Manager is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity 0.8.11;
import "@skalenetwork/skale-manager-interfaces/IContractManager.sol";
import "@skalenetwork/skale-manager-interfaces/IPermissions.sol";
import "./thirdparty/openzeppelin/AccessControlUpgradeableLegacy.sol";
/**
* @title Permissions
* @dev Contract is connected module for Upgradeable approach, knows ContractManager
*/
contract Permissions is AccessControlUpgradeableLegacy, IPermissions {
using AddressUpgradeable for address;
IContractManager public contractManager;
/**
* @dev Modifier to make a function callable only when caller is the Owner.
*
* Requirements:
*
* - The caller must be the owner.
*/
modifier onlyOwner() {
require(_isOwner(), "Caller is not the owner");
_;
}
/**
* @dev Modifier to make a function callable only when caller is an Admin.
*
* Requirements:
*
* - The caller must be an admin.
*/
modifier onlyAdmin() {
require(_isAdmin(msg.sender), "Caller is not an admin");
_;
}
/**
* @dev Modifier to make a function callable only when caller is the Owner
* or `contractName` contract.
*
* Requirements:
*
* - The caller must be the owner or `contractName`.
*/
modifier allow(string memory contractName) {
require(
contractManager.getContract(contractName) == msg.sender || _isOwner(),
"Message sender is invalid");
_;
}
/**
* @dev Modifier to make a function callable only when caller is the Owner
* or `contractName1` or `contractName2` contract.
*
* Requirements:
*
* - The caller must be the owner, `contractName1`, or `contractName2`.
*/
modifier allowTwo(string memory contractName1, string memory contractName2) {
require(
contractManager.getContract(contractName1) == msg.sender ||
contractManager.getContract(contractName2) == msg.sender ||
_isOwner(),
"Message sender is invalid");
_;
}
/**
* @dev Modifier to make a function callable only when caller is the Owner
* or `contractName1`, `contractName2`, or `contractName3` contract.
*
* Requirements:
*
* - The caller must be the owner, `contractName1`, `contractName2`, or
* `contractName3`.
*/
modifier allowThree(string memory contractName1, string memory contractName2, string memory contractName3) {
require(
contractManager.getContract(contractName1) == msg.sender ||
contractManager.getContract(contractName2) == msg.sender ||
contractManager.getContract(contractName3) == msg.sender ||
_isOwner(),
"Message sender is invalid");
_;
}
function initialize(address contractManagerAddress) public virtual override initializer {
AccessControlUpgradeableLegacy.__AccessControl_init();
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
_setContractManager(contractManagerAddress);
}
function _isOwner() internal view returns (bool) {
return hasRole(DEFAULT_ADMIN_ROLE, msg.sender);
}
function _isAdmin(address account) internal view returns (bool) {
address skaleManagerAddress = contractManager.contracts(keccak256(abi.encodePacked("SkaleManager")));
if (skaleManagerAddress != address(0)) {
AccessControlUpgradeableLegacy skaleManager = AccessControlUpgradeableLegacy(skaleManagerAddress);
return skaleManager.hasRole(keccak256("ADMIN_ROLE"), account) || _isOwner();
} else {
return _isOwner();
}
}
function _setContractManager(address contractManagerAddress) private {
require(contractManagerAddress != address(0), "ContractManager address is not set");
require(contractManagerAddress.isContract(), "Address is not contract");
contractManager = IContractManager(contractManagerAddress);
}
}
// SPDX-License-Identifier: AGPL-3.0-only
/*
ConstantsHolder.sol - SKALE Manager
Copyright (C) 2018-Present SKALE Labs
@author Artem Payvin
SKALE Manager is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity 0.8.11;
import "@skalenetwork/skale-manager-interfaces/IConstantsHolder.sol";
import "./Permissions.sol";
/**
* @title ConstantsHolder
* @dev Contract contains constants and common variables for the SKALE Network.
*/
contract ConstantsHolder is Permissions, IConstantsHolder {
// initial price for creating Node (100 SKL)
uint public constant NODE_DEPOSIT = 100 * 1e18;
uint8 public constant TOTAL_SPACE_ON_NODE = 128;
// part of Node for Small Skale-chain (1/128 of Node)
uint8 public constant SMALL_DIVISOR = 128;
// part of Node for Medium Skale-chain (1/32 of Node)
uint8 public constant MEDIUM_DIVISOR = 32;
// part of Node for Large Skale-chain (full Node)
uint8 public constant LARGE_DIVISOR = 1;
// part of Node for Medium Test Skale-chain (1/4 of Node)
uint8 public constant MEDIUM_TEST_DIVISOR = 4;
// typically number of Nodes for Skale-chain (16 Nodes)
uint public constant NUMBER_OF_NODES_FOR_SCHAIN = 16;
// number of Nodes for Test Skale-chain (2 Nodes)
uint public constant NUMBER_OF_NODES_FOR_TEST_SCHAIN = 2;
// number of Nodes for Test Skale-chain (4 Nodes)
uint public constant NUMBER_OF_NODES_FOR_MEDIUM_TEST_SCHAIN = 4;
// number of seconds in one year
uint32 public constant SECONDS_TO_YEAR = 31622400;
// initial number of monitors
uint public constant NUMBER_OF_MONITORS = 24;
uint public constant OPTIMAL_LOAD_PERCENTAGE = 80;
uint public constant ADJUSTMENT_SPEED = 1000;
uint public constant COOLDOWN_TIME = 60;
uint public constant MIN_PRICE = 10**6;
uint public constant MSR_REDUCING_COEFFICIENT = 2;
uint public constant DOWNTIME_THRESHOLD_PART = 30;
uint public constant BOUNTY_LOCKUP_MONTHS = 2;
uint public constant ALRIGHT_DELTA = 134161;
uint public constant BROADCAST_DELTA = 177490;
uint public constant COMPLAINT_BAD_DATA_DELTA = 80995;
uint public constant PRE_RESPONSE_DELTA = 100061;
uint public constant COMPLAINT_DELTA = 104611;
uint public constant RESPONSE_DELTA = 49132;
// MSR - Minimum staking requirement
uint public msr;
// Reward period - 30 days (each 30 days Node would be granted for bounty)
uint32 public rewardPeriod;
// Allowable latency - 150000 ms by default
uint32 public allowableLatency;
/**
* Delta period - 1 hour (1 hour before Reward period became Monitors need
* to send Verdicts and 1 hour after Reward period became Node need to come
* and get Bounty)
*/
uint32 public deltaPeriod;
/**
* Check time - 2 minutes (every 2 minutes monitors should check metrics
* from checked nodes)
*/
uint public checkTime;
//Need to add minimal allowed parameters for verdicts
uint public launchTimestamp;
uint public rotationDelay;
uint public proofOfUseLockUpPeriodDays;
uint public proofOfUseDelegationPercentage;
uint public limitValidatorsPerDelegator;
uint256 public firstDelegationsMonth; // deprecated
// date when schains will be allowed for creation
uint public schainCreationTimeStamp;
uint public minimalSchainLifetime;
uint public complaintTimeLimit;
bytes32 public constant CONSTANTS_HOLDER_MANAGER_ROLE = keccak256("CONSTANTS_HOLDER_MANAGER_ROLE");
modifier onlyConstantsHolderManager() {
require(hasRole(CONSTANTS_HOLDER_MANAGER_ROLE, msg.sender), "CONSTANTS_HOLDER_MANAGER_ROLE is required");
_;
}
/**
* @dev Allows the Owner to set new reward and delta periods
* This function is only for tests.
*/
function setPeriods(uint32 newRewardPeriod, uint32 newDeltaPeriod) external override onlyConstantsHolderManager {
require(
newRewardPeriod >= newDeltaPeriod && newRewardPeriod - newDeltaPeriod >= checkTime,
"Incorrect Periods"
);
emit ConstantUpdated(
keccak256(abi.encodePacked("RewardPeriod")),
uint(rewardPeriod),
uint(newRewardPeriod)
);
rewardPeriod = newRewardPeriod;
emit ConstantUpdated(
keccak256(abi.encodePacked("DeltaPeriod")),
uint(deltaPeriod),
uint(newDeltaPeriod)
);
deltaPeriod = newDeltaPeriod;
}
/**
* @dev Allows the Owner to set the new check time.
* This function is only for tests.
*/
function setCheckTime(uint newCheckTime) external override onlyConstantsHolderManager {
require(rewardPeriod - deltaPeriod >= checkTime, "Incorrect check time");
emit ConstantUpdated(
keccak256(abi.encodePacked("CheckTime")),
uint(checkTime),
uint(newCheckTime)
);
checkTime = newCheckTime;
}
/**
* @dev Allows the Owner to set the allowable latency in milliseconds.
* This function is only for testing purposes.
*/
function setLatency(uint32 newAllowableLatency) external override onlyConstantsHolderManager {
emit ConstantUpdated(
keccak256(abi.encodePacked("AllowableLatency")),
uint(allowableLatency),
uint(newAllowableLatency)
);
allowableLatency = newAllowableLatency;
}
/**
* @dev Allows the Owner to set the minimum stake requirement.
*/
function setMSR(uint newMSR) external override onlyConstantsHolderManager {
emit ConstantUpdated(
keccak256(abi.encodePacked("MSR")),
uint(msr),
uint(newMSR)
);
msr = newMSR;
}
/**
* @dev Allows the Owner to set the launch timestamp.
*/
function setLaunchTimestamp(uint timestamp) external override onlyConstantsHolderManager {
require(
block.timestamp < launchTimestamp,
"Cannot set network launch timestamp because network is already launched"
);
emit ConstantUpdated(
keccak256(abi.encodePacked("LaunchTimestamp")),
uint(launchTimestamp),
uint(timestamp)
);
launchTimestamp = timestamp;
}
/**
* @dev Allows the Owner to set the node rotation delay.
*/
function setRotationDelay(uint newDelay) external override onlyConstantsHolderManager {
emit ConstantUpdated(
keccak256(abi.encodePacked("RotationDelay")),
uint(rotationDelay),
uint(newDelay)
);
rotationDelay = newDelay;
}
/**
* @dev Allows the Owner to set the proof-of-use lockup period.
*/
function setProofOfUseLockUpPeriod(uint periodDays) external override onlyConstantsHolderManager {
emit ConstantUpdated(
keccak256(abi.encodePacked("ProofOfUseLockUpPeriodDays")),
uint(proofOfUseLockUpPeriodDays),
uint(periodDays)
);
proofOfUseLockUpPeriodDays = periodDays;
}
/**
* @dev Allows the Owner to set the proof-of-use delegation percentage
* requirement.
*/
function setProofOfUseDelegationPercentage(uint percentage) external override onlyConstantsHolderManager {
require(percentage <= 100, "Percentage value is incorrect");
emit ConstantUpdated(
keccak256(abi.encodePacked("ProofOfUseDelegationPercentage")),
uint(proofOfUseDelegationPercentage),
uint(percentage)
);
proofOfUseDelegationPercentage = percentage;
}
/**
* @dev Allows the Owner to set the maximum number of validators that a
* single delegator can delegate to.
*/
function setLimitValidatorsPerDelegator(uint newLimit) external override onlyConstantsHolderManager {
emit ConstantUpdated(
keccak256(abi.encodePacked("LimitValidatorsPerDelegator")),
uint(limitValidatorsPerDelegator),
uint(newLimit)
);
limitValidatorsPerDelegator = newLimit;
}
function setSchainCreationTimeStamp(uint timestamp) external override onlyConstantsHolderManager {
emit ConstantUpdated(
keccak256(abi.encodePacked("SchainCreationTimeStamp")),
uint(schainCreationTimeStamp),
uint(timestamp)
);
schainCreationTimeStamp = timestamp;
}
function setMinimalSchainLifetime(uint lifetime) external override onlyConstantsHolderManager {
emit ConstantUpdated(
keccak256(abi.encodePacked("MinimalSchainLifetime")),
uint(minimalSchainLifetime),
uint(lifetime)
);
minimalSchainLifetime = lifetime;
}
function setComplaintTimeLimit(uint timeLimit) external override onlyConstantsHolderManager {
emit ConstantUpdated(
keccak256(abi.encodePacked("ComplaintTimeLimit")),
uint(complaintTimeLimit),
uint(timeLimit)
);
complaintTimeLimit = timeLimit;
}
function initialize(address contractsAddress) public override initializer {
Permissions.initialize(contractsAddress);
msr = 0;
rewardPeriod = 2592000;
allowableLatency = 150000;
deltaPeriod = 3600;
checkTime = 300;
launchTimestamp = type(uint).max;
rotationDelay = 12 hours;
proofOfUseLockUpPeriodDays = 90;
proofOfUseDelegationPercentage = 50;
limitValidatorsPerDelegator = 20;
firstDelegationsMonth = 0;
complaintTimeLimit = 1800;
}
}
// SPDX-License-Identifier: AGPL-3.0-only
/*
IRandom.sol - SKALE Manager Interfaces
Copyright (C) 2022-Present SKALE Labs
@author Dmytro Stebaiev
SKALE Manager Interfaces is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager Interfaces is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager Interfaces. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.10 <0.9.0;
interface IRandom {
struct RandomGenerator {
uint seed;
}
}
// SPDX-License-Identifier: AGPL-3.0-only
/*
IContractManager.sol - SKALE Manager Interfaces
Copyright (C) 2021-Present SKALE Labs
@author Dmytro Stebaeiv
SKALE Manager Interfaces is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager Interfaces is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager Interfaces. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.10 <0.9.0;
interface IContractManager {
/**
* @dev Emitted when contract is upgraded.
*/
event ContractUpgraded(string contractsName, address contractsAddress);
function initialize() external;
function setContractsAddress(string calldata contractsName, address newContractsAddress) external;
function contracts(bytes32 nameHash) external view returns (address);
function getDelegationPeriodManager() external view returns (address);
function getBounty() external view returns (address);
function getValidatorService() external view returns (address);
function getTimeHelpers() external view returns (address);
function getConstantsHolder() external view returns (address);
function getSkaleToken() external view returns (address);
function getTokenState() external view returns (address);
function getPunisher() external view returns (address);
function getContract(string calldata name) external view returns (address);
}
// SPDX-License-Identifier: AGPL-3.0-only
/*
IPermissions.sol - SKALE Manager
Copyright (C) 2018-Present SKALE Labs
@author Artem Payvin
SKALE Manager is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.10 <0.9.0;
interface IPermissions {
function initialize(address contractManagerAddress) external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
import "@skalenetwork/skale-manager-interfaces/thirdparty/openzeppelin/IAccessControlUpgradeableLegacy.sol";
import "./InitializableWithGap.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, _msgSender()));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*/
abstract contract AccessControlUpgradeableLegacy is InitializableWithGap, ContextUpgradeable, IAccessControlUpgradeableLegacy {
function __AccessControl_init() internal initializer {
__Context_init_unchained();
__AccessControl_init_unchained();
}
function __AccessControl_init_unchained() internal initializer {
}
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
struct RoleData {
EnumerableSetUpgradeable.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members.contains(account);
}
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) public view override returns (uint256) {
return _roles[role].members.length();
}
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) public view override returns (address) {
return _roles[role].members.at(index);
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) public virtual override {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) public virtual override {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)
pragma solidity ^0.8.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*/
library EnumerableSetUpgradeable {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
/**
* @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 ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
__Context_init_unchained();
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: AGPL-3.0-only
/*
IAccessControlUpgradeableLegacy.sol - SKALE Manager
Copyright (C) 2018-Present SKALE Labs
@author Artem Payvin
SKALE Manager is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.10 <0.9.0;
interface IAccessControlUpgradeableLegacy {
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleMemberCount(bytes32 role) external view returns (uint256);
function getRoleMember(bytes32 role, uint256 index) external view returns (address);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
}
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.7;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
contract InitializableWithGap is Initializable {
uint256[50] private ______gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/utils/Initializable.sol)
pragma solidity ^0.8.0;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the
* initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() initializer {}
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Modifier to protect an initializer function from being invoked twice.
*/
modifier initializer() {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
// contract may have been reentered.
require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} modifier, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
pragma solidity ^0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @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) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @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");
(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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
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
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// SPDX-License-Identifier: AGPL-3.0-only
/*
IConstantsHolder.sol - SKALE Manager Interfaces
Copyright (C) 2021-Present SKALE Labs
@author Artem Payvin
SKALE Manager Interfaces is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
SKALE Manager Interfaces is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with SKALE Manager Interfaces. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.10 <0.9.0;
interface IConstantsHolder {
/**
* @dev Emitted when constants updated.
*/
event ConstantUpdated(
bytes32 indexed constantHash,
uint previousValue,
uint newValue
);
function setPeriods(uint32 newRewardPeriod, uint32 newDeltaPeriod) external;
function setCheckTime(uint newCheckTime) external;
function setLatency(uint32 newAllowableLatency) external;
function setMSR(uint newMSR) external;
function setLaunchTimestamp(uint timestamp) external;
function setRotationDelay(uint newDelay) external;
function setProofOfUseLockUpPeriod(uint periodDays) external;
function setProofOfUseDelegationPercentage(uint percentage) external;
function setLimitValidatorsPerDelegator(uint newLimit) external;
function setSchainCreationTimeStamp(uint timestamp) external;
function setMinimalSchainLifetime(uint lifetime) external;
function setComplaintTimeLimit(uint timeLimit) external;
function msr() external view returns (uint);
function launchTimestamp() external view returns (uint);
function rotationDelay() external view returns (uint);
function limitValidatorsPerDelegator() external view returns (uint);
function schainCreationTimeStamp() external view returns (uint);
function minimalSchainLifetime() external view returns (uint);
function complaintTimeLimit() external view returns (uint);
} | * @dev Adjust the schain price based on network capacity and demand. Requirements: - Cooldown time has exceeded./ | function adjustPrice() external override {
ConstantsHolder constantsHolder = ConstantsHolder(contractManager.getContract("ConstantsHolder"));
require(
block.timestamp > lastUpdated + constantsHolder.COOLDOWN_TIME(),
"It's not a time to update a price"
);
checkAllNodes();
uint load = _getTotalLoad();
uint capacity = _getTotalCapacity();
bool networkIsOverloaded = load * 100 > constantsHolder.OPTIMAL_LOAD_PERCENTAGE() * capacity;
uint loadDiff;
if (networkIsOverloaded) {
loadDiff = load * 100 - constantsHolder.OPTIMAL_LOAD_PERCENTAGE() * capacity;
loadDiff = constantsHolder.OPTIMAL_LOAD_PERCENTAGE() * capacity - load * 100;
}
uint priceChangeSpeedMultipliedByCapacityAndMinPrice =
constantsHolder.ADJUSTMENT_SPEED() * loadDiff * price;
uint timeSkipped = block.timestamp - lastUpdated;
uint priceChange = priceChangeSpeedMultipliedByCapacityAndMinPrice
* timeSkipped
/ constantsHolder.COOLDOWN_TIME()
/ capacity
/ constantsHolder.MIN_PRICE();
if (networkIsOverloaded) {
assert(priceChange > 0);
price = price + priceChange;
if (priceChange > price) {
price = constantsHolder.MIN_PRICE();
price = price - priceChange;
if (price < constantsHolder.MIN_PRICE()) {
price = constantsHolder.MIN_PRICE();
}
}
}
lastUpdated = block.timestamp;
}
| 12,234,367 | [
1,
10952,
326,
272,
5639,
6205,
2511,
603,
2483,
7519,
471,
23653,
18,
29076,
30,
300,
385,
1371,
2378,
813,
711,
12428,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
5765,
5147,
1435,
3903,
3849,
288,
203,
3639,
5245,
6064,
6810,
6064,
273,
5245,
6064,
12,
16351,
1318,
18,
588,
8924,
2932,
2918,
6064,
7923,
1769,
203,
3639,
2583,
12,
203,
5411,
1203,
18,
5508,
405,
1142,
7381,
397,
6810,
6064,
18,
3865,
1741,
12711,
67,
4684,
9334,
203,
5411,
315,
7193,
1807,
486,
279,
813,
358,
1089,
279,
6205,
6,
203,
3639,
11272,
203,
3639,
866,
1595,
3205,
5621,
203,
3639,
2254,
1262,
273,
389,
588,
5269,
2563,
5621,
203,
3639,
2254,
7519,
273,
389,
588,
5269,
7437,
5621,
203,
203,
3639,
1426,
2483,
2520,
4851,
4230,
273,
1262,
380,
2130,
405,
6810,
6064,
18,
15620,
14762,
67,
7783,
67,
3194,
19666,
2833,
1435,
380,
7519,
31,
203,
3639,
2254,
1262,
5938,
31,
203,
3639,
309,
261,
5185,
2520,
4851,
4230,
13,
288,
203,
5411,
1262,
5938,
273,
1262,
380,
2130,
300,
6810,
6064,
18,
15620,
14762,
67,
7783,
67,
3194,
19666,
2833,
1435,
380,
7519,
31,
203,
5411,
1262,
5938,
273,
6810,
6064,
18,
15620,
14762,
67,
7783,
67,
3194,
19666,
2833,
1435,
380,
7519,
300,
1262,
380,
2130,
31,
203,
3639,
289,
203,
203,
3639,
2254,
6205,
3043,
16562,
5002,
3110,
858,
7437,
1876,
2930,
5147,
273,
203,
5411,
6810,
6064,
18,
1880,
46,
5996,
3212,
67,
23810,
2056,
1435,
380,
1262,
5938,
380,
6205,
31,
203,
540,
203,
3639,
2254,
813,
16425,
273,
1203,
18,
5508,
300,
1142,
7381,
31,
203,
540,
203,
3639,
2254,
6205,
3043,
273,
6205,
3043,
16562,
5002,
3110,
858,
7437,
1876,
2930,
5147,
2
] |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.8;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract MerkleRedeem is AccessControl {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant SEEDER_ROLE = keccak256("SEEDER_ROLE");
IERC20 public token;
uint64 public minDelay;
event Claimed(address indexed _contributor, uint256 _balance);
event DistributionPublished(uint indexed _id, bytes32 _root);
event DistributionPaused(uint indexed _id);
// Recorded Distributions
mapping(uint => bytes32) public distributionMerkleRoots;
mapping(uint => mapping(address => bool)) public claimed;
mapping(uint => uint64) public claimTimes;
constructor(
address _token,
uint64 _minDelay
) public {
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
minDelay = _minDelay;
token = IERC20(_token);
}
function disburse(
address _contributor,
uint _balance
)
private
{
if (_balance > 0) {
emit Claimed(_contributor, _balance);
require(token.transfer(_contributor, _balance), "MerkleRedeem: ERR_TRANSFER_FAILED");
}
}
/**
* @dev ensure the contract's token balance is sufficient before calling
* a claimWeek function.
*/
function claimWeek(
address _contributor,
uint _distribution,
uint _claimedBalance,
bytes32[] memory _merkleProof
)
public
{
require(!claimed[_distribution][_contributor], "MerkleRedeem: Already claimed");
require(block.timestamp > claimTimes[_distribution], "MerkleRedeem: Distribution still paused");
require(verifyClaim(_contributor, _distribution, _claimedBalance, _merkleProof), 'MerkleRedeem: Incorrect merkle proof');
claimed[_distribution][_contributor] = true;
disburse(_contributor, _claimedBalance);
}
struct Claim {
uint distributionIdx;
uint balance;
bytes32[] merkleProof;
}
/**
* @dev ensure the contract's token balance is sufficient before calling
* the claimWeeks function.
*/
function claimWeeks(
address _contributor,
Claim[] memory claims
)
public
{
uint totalBalance = 0;
Claim memory claim ;
for(uint i = 0; i < claims.length; i++) {
claim = claims[i];
require(block.timestamp > claimTimes[claim.distributionIdx], "MerkleRedeem: Distribution still paused");
require(!claimed[claim.distributionIdx][_contributor]);
require(verifyClaim(_contributor, claim.distributionIdx, claim.balance, claim.merkleProof), 'MerkleRedeem: Incorrect merkle proof');
totalBalance += claim.balance;
claimed[claim.distributionIdx][_contributor] = true;
}
disburse(_contributor, totalBalance);
}
/**
* Get the claim status for a user for a slice of distributions.
* Will return false for a non-existent distribution.
*
* The `_end` value is included in the returned array
*/
function claimStatus(
address _contributor,
uint _begin,
uint _end
)
external
view
returns (bool[] memory)
{
uint size = 1 + _end - _begin;
bool[] memory arr = new bool[](size);
for(uint i = 0; i < size; i++) {
arr[i] = claimed[_begin + i][_contributor];
}
return arr;
}
/**
* Get the bytes32 hash merkle root for a slice of all valid
* distributions. This will return bytes32(0) if a distribution is
* paused or non-existent. Non-existent distributions have a `claimTime`
* of zero.
*
* The `_end` value is included in the returned array
*/
function merkleRoots(
uint _begin,
uint _end
)
external
view
returns (bytes32[] memory)
{
uint size = 1 + _end - _begin;
bytes32[] memory arr = new bytes32[](size);
for(uint i = 0; i < size; i++) {
arr[i] = distributionMerkleRoots[_begin + i];
}
return arr;
}
/**
* Check the validity of a claim attempt
*/
function verifyClaim(
address _contributor,
uint _distribution,
uint _claimedBalance,
bytes32[] memory _merkleProof
)
public
view
returns (bool valid)
{
bytes32 leaf = keccak256(abi.encodePacked(_contributor, _claimedBalance));
return MerkleProof.verify(_merkleProof, distributionMerkleRoots[_distribution], leaf);
}
/**
* Publish a merkleRoot that contributors can validate against to claim
* funds. Currently the _claimTime can be set to any time past or present,
* but this may not be the case when ultimately released. Distributions
* might need to observe some minimum delay period before claims
* can successfully execute against it.
*/
function seedDistribution(
uint _distribution,
bytes32 _merkleRoot,
uint64 _claimTime
)
external
{
require(hasRole(SEEDER_ROLE, msg.sender), "MerkleRedeem: Must have SEEDER_ROLE to post allocation roots");
require(distributionMerkleRoots[_distribution] == bytes32(0), "MerkleRedeem: cannot rewrite merkle root");
require(block.timestamp + minDelay <= _claimTime, "MerkleRedeem: Delay is too short");
distributionMerkleRoots[_distribution] = _merkleRoot;
claimTimes[_distribution] = _claimTime;
emit DistributionPublished(_distribution, _merkleRoot);
}
/**
* Pause a Distribution by resetting the merkle root to zero
* The distribution can be re-seeded with a new merkle root.
* The caller must have the `PAUSER_ROLE` and the distribution cannot be
* "live", i.e. the `claimTime` cannot have passed.
*
* This effectively pauses the distribution indefinitely, since it can
* still be re-seeded with `seedDistribution`
*/
function removeDistribution(uint _distribution) external {
require(hasRole(PAUSER_ROLE, msg.sender), "MerkleRedeem: Must have PAUSER_ROLE to modify allocations");
require(block.timestamp < claimTimes[_distribution], "MerkleRedeem: Can't modify a live distribution");
distributionMerkleRoots[_distribution] = bytes32(0);
emit DistributionPaused(_distribution);
}
/**
* Pauser Role can modify the global minumum delay
*/
function changeMinimumDelay(uint64 _newDelay) external {
require(hasRole(PAUSER_ROLE, msg.sender), "MerkleRedeem: Must have PAUSER_ROLE to modify allocations");
minDelay = _newDelay;
}
/**
* Used to withdraw unclaimed funds or empty the contract in the event
* of an emergency.
*/
function withdrawFunds(uint _amount) external {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "MerkleRedeem: Must have DEFAULT_ADMIN_ROLE to withdraw funds from the contract");
require(token.transfer(msg.sender, _amount), "MerkleRedeem: ERR_TRANSFER_FAILED");
}
}
| * Get the claim status for a user for a slice of distributions. Will return false for a non-existent distribution. The `_end` value is included in the returned array/ | function claimStatus(
address _contributor,
uint _begin,
uint _end
)
external
view
returns (bool[] memory)
{
uint size = 1 + _end - _begin;
bool[] memory arr = new bool[](size);
for(uint i = 0; i < size; i++) {
arr[i] = claimed[_begin + i][_contributor];
}
return arr;
}
| 12,618,519 | [
1,
967,
326,
7516,
1267,
364,
279,
729,
364,
279,
2788,
434,
23296,
18,
9980,
327,
629,
364,
279,
1661,
17,
19041,
7006,
18,
1021,
1375,
67,
409,
68,
460,
353,
5849,
316,
326,
2106,
526,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
7516,
1482,
12,
203,
3639,
1758,
389,
591,
19293,
16,
203,
3639,
2254,
389,
10086,
16,
203,
3639,
2254,
389,
409,
203,
565,
262,
203,
3639,
3903,
203,
3639,
1476,
203,
3639,
1135,
261,
6430,
8526,
3778,
13,
203,
565,
288,
203,
3639,
2254,
963,
273,
404,
397,
389,
409,
300,
389,
10086,
31,
203,
3639,
1426,
8526,
3778,
2454,
273,
394,
1426,
8526,
12,
1467,
1769,
203,
3639,
364,
12,
11890,
277,
273,
374,
31,
277,
411,
963,
31,
277,
27245,
288,
203,
5411,
2454,
63,
77,
65,
273,
7516,
329,
63,
67,
10086,
397,
277,
6362,
67,
591,
19293,
15533,
203,
3639,
289,
203,
3639,
327,
2454,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity ^0.4.23;
// File: contracts/BytesUtils.sol
library BytesUtils {
/*
* @dev Returns the keccak-256 hash of a byte range.
* @param self The byte string to hash.
* @param offset The position to start hashing at.
* @param len The number of bytes to hash.
* @return The hash of the byte range.
*/
function keccak(bytes memory self, uint offset, uint len) internal pure returns (bytes32 ret) {
require(offset + len <= self.length);
assembly {
ret := sha3(add(add(self, 32), offset), len)
}
}
/*
* @dev Returns a positive number if `other` comes lexicographically after
* `self`, a negative number if it comes before, or zero if the
* contents of the two bytes are equal.
* @param self The first bytes to compare.
* @param other The second bytes to compare.
* @return The result of the comparison.
*/
function compare(bytes memory self, bytes memory other) internal pure returns (int) {
return compare(self, 0, self.length, other, 0, other.length);
}
/*
* @dev Returns a positive number if `other` comes lexicographically after
* `self`, a negative number if it comes before, or zero if the
* contents of the two bytes are equal. Comparison is done per-rune,
* on unicode codepoints.
* @param self The first bytes to compare.
* @param offset The offset of self.
* @param len The length of self.
* @param other The second bytes to compare.
* @param otheroffset The offset of the other string.
* @param otherlen The length of the other string.
* @return The result of the comparison.
*/
function compare(bytes memory self, uint offset, uint len, bytes memory other, uint otheroffset, uint otherlen) internal pure returns (int) {
uint shortest = len;
if (otherlen < len)
shortest = otherlen;
uint selfptr;
uint otherptr;
assembly {
selfptr := add(self, add(offset, 32))
otherptr := add(other, add(otheroffset, 32))
}
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
// Mask out irrelevant bytes and check again
uint mask;
if (shortest > 32) {
mask = uint256(- 1); // aka 0xffffff....
} else {
mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
}
uint diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
selfptr += 32;
otherptr += 32;
}
return int(len) - int(otherlen);
}
/*
* @dev Returns true if the two byte ranges are equal.
* @param self The first byte range to compare.
* @param offset The offset into the first byte range.
* @param other The second byte range to compare.
* @param otherOffset The offset into the second byte range.
* @param len The number of bytes to compare
* @return True if the byte ranges are equal, false otherwise.
*/
function equals(bytes memory self, uint offset, bytes memory other, uint otherOffset, uint len) internal pure returns (bool) {
return keccak(self, offset, len) == keccak(other, otherOffset, len);
}
/*
* @dev Returns true if the two byte ranges are equal with offsets.
* @param self The first byte range to compare.
* @param offset The offset into the first byte range.
* @param other The second byte range to compare.
* @param otherOffset The offset into the second byte range.
* @return True if the byte ranges are equal, false otherwise.
*/
function equals(bytes memory self, uint offset, bytes memory other, uint otherOffset) internal pure returns (bool) {
return keccak(self, offset, self.length - offset) == keccak(other, otherOffset, other.length - otherOffset);
}
/*
* @dev Compares a range of 'self' to all of 'other' and returns True iff
* they are equal.
* @param self The first byte range to compare.
* @param offset The offset into the first byte range.
* @param other The second byte range to compare.
* @return True if the byte ranges are equal, false otherwise.
*/
function equals(bytes memory self, uint offset, bytes memory other) internal pure returns (bool) {
return self.length >= offset + other.length && equals(self, offset, other, 0, other.length);
}
/*
* @dev Returns true if the two byte ranges are equal.
* @param self The first byte range to compare.
* @param other The second byte range to compare.
* @return True if the byte ranges are equal, false otherwise.
*/
function equals(bytes memory self, bytes memory other) internal pure returns(bool) {
return self.length == other.length && equals(self, 0, other, 0, self.length);
}
/*
* @dev Returns the 8-bit number at the specified index of self.
* @param self The byte string.
* @param idx The index into the bytes
* @return The specified 8 bits of the string, interpreted as an integer.
*/
function readUint8(bytes memory self, uint idx) internal pure returns (uint8 ret) {
require(idx + 1 <= self.length);
assembly {
ret := and(mload(add(add(self, 1), idx)), 0xFF)
}
}
/*
* @dev Returns the 16-bit number at the specified index of self.
* @param self The byte string.
* @param idx The index into the bytes
* @return The specified 16 bits of the string, interpreted as an integer.
*/
function readUint16(bytes memory self, uint idx) internal pure returns (uint16 ret) {
require(idx + 2 <= self.length);
assembly {
ret := and(mload(add(add(self, 2), idx)), 0xFFFF)
}
}
/*
* @dev Returns the 32-bit number at the specified index of self.
* @param self The byte string.
* @param idx The index into the bytes
* @return The specified 32 bits of the string, interpreted as an integer.
*/
function readUint32(bytes memory self, uint idx) internal pure returns (uint32 ret) {
require(idx + 4 <= self.length);
assembly {
ret := and(mload(add(add(self, 4), idx)), 0xFFFFFFFF)
}
}
/*
* @dev Returns the 32 byte value at the specified index of self.
* @param self The byte string.
* @param idx The index into the bytes
* @return The specified 32 bytes of the string.
*/
function readBytes32(bytes memory self, uint idx) internal pure returns (bytes32 ret) {
require(idx + 32 <= self.length);
assembly {
ret := mload(add(add(self, 32), idx))
}
}
/*
* @dev Returns the 32 byte value at the specified index of self.
* @param self The byte string.
* @param idx The index into the bytes
* @return The specified 32 bytes of the string.
*/
function readBytes20(bytes memory self, uint idx) internal pure returns (bytes20 ret) {
require(idx + 20 <= self.length);
assembly {
ret := and(mload(add(add(self, 32), idx)), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000)
}
}
/*
* @dev Returns the n byte value at the specified index of self.
* @param self The byte string.
* @param idx The index into the bytes.
* @param len The number of bytes.
* @return The specified 32 bytes of the string.
*/
function readBytesN(bytes memory self, uint idx, uint len) internal pure returns (bytes20 ret) {
require(idx + len <= self.length);
assembly {
let mask := not(sub(exp(256, sub(32, len)), 1))
ret := and(mload(add(add(self, 32), idx)), mask)
}
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for (; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
/*
* @dev Copies a substring into a new byte string.
* @param self The byte string to copy from.
* @param offset The offset to start copying at.
* @param len The number of bytes to copy.
*/
function substring(bytes memory self, uint offset, uint len) internal pure returns(bytes) {
require(offset + len <= self.length);
bytes memory ret = new bytes(len);
uint dest;
uint src;
assembly {
dest := add(ret, 32)
src := add(add(self, 32), offset)
}
memcpy(dest, src, len);
return ret;
}
// Maps characters from 0x30 to 0x7A to their base32 values.
// 0xFF represents invalid characters in that range.
bytes constant base32HexTable = hex'00010203040506070809FFFFFFFFFFFFFF0A0B0C0D0E0F101112131415161718191A1B1C1D1E1FFFFFFFFFFFFFFFFFFFFF0A0B0C0D0E0F101112131415161718191A1B1C1D1E1F';
/**
* @dev Decodes unpadded base32 data of up to one word in length.
* @param self The data to decode.
* @param off Offset into the string to start at.
* @param len Number of characters to decode.
* @return The decoded data, left aligned.
*/
function base32HexDecodeWord(bytes memory self, uint off, uint len) internal pure returns(bytes32) {
require(len <= 52);
uint ret = 0;
for(uint i = 0; i < len; i++) {
byte char = self[off + i];
require(char >= 0x30 && char <= 0x7A);
uint8 decoded = uint8(base32HexTable[uint(char) - 0x30]);
require(decoded <= 0x20);
if(i == len - 1) {
break;
}
ret = (ret << 5) | decoded;
}
uint bitlen = len * 5;
if(len % 8 == 0) {
// Multiple of 8 characters, no padding
ret = (ret << 5) | decoded;
} else if(len % 8 == 2) {
// Two extra characters - 1 byte
ret = (ret << 3) | (decoded >> 2);
bitlen -= 2;
} else if(len % 8 == 4) {
// Four extra characters - 2 bytes
ret = (ret << 1) | (decoded >> 4);
bitlen -= 4;
} else if(len % 8 == 5) {
// Five extra characters - 3 bytes
ret = (ret << 4) | (decoded >> 1);
bitlen -= 1;
} else if(len % 8 == 7) {
// Seven extra characters - 4 bytes
ret = (ret << 2) | (decoded >> 3);
bitlen -= 3;
} else {
revert();
}
return bytes32(ret << (256 - bitlen));
}
}
// File: contracts/DNSSEC.sol
interface DNSSEC {
event AlgorithmUpdated(uint8 id, address addr);
event DigestUpdated(uint8 id, address addr);
event NSEC3DigestUpdated(uint8 id, address addr);
event RRSetUpdated(bytes name, bytes rrset);
function submitRRSets(bytes memory data, bytes memory proof) public returns (bytes);
function submitRRSet(bytes memory input, bytes memory sig, bytes memory proof) public returns(bytes memory rrs);
function deleteRRSet(uint16 deleteType, bytes deleteName, bytes memory nsec, bytes memory sig, bytes memory proof) public;
function rrdata(uint16 dnstype, bytes memory name) public view returns (uint32, uint64, bytes20);
}
// File: contracts/Owned.sol
/**
* @dev Contract mixin for 'owned' contracts.
*/
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier owner_only() {
require(msg.sender == owner);
_;
}
function setOwner(address newOwner) public owner_only {
owner = newOwner;
}
}
// File: @ensdomains/buffer/contracts/Buffer.sol
/**
* @dev A library for working with mutable byte buffers in Solidity.
*
* Byte buffers are mutable and expandable, and provide a variety of primitives
* for writing to them. At any time you can fetch a bytes object containing the
* current contents of the buffer. The bytes object should not be stored between
* operations, as it may change due to resizing of the buffer.
*/
library Buffer {
/**
* @dev Represents a mutable buffer. Buffers have a current value (buf) and
* a capacity. The capacity may be longer than the current value, in
* which case it can be extended without the need to allocate more memory.
*/
struct buffer {
bytes buf;
uint capacity;
}
/**
* @dev Initializes a buffer with an initial capacity.
* @param buf The buffer to initialize.
* @param capacity The number of bytes of space to allocate the buffer.
* @return The buffer, for chaining.
*/
function init(buffer memory buf, uint capacity) internal pure returns(buffer memory) {
if (capacity % 32 != 0) {
capacity += 32 - (capacity % 32);
}
// Allocate space for the buffer data
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(ptr, 0)
mstore(0x40, add(ptr, capacity))
}
return buf;
}
/**
* @dev Initializes a new buffer from an existing bytes object.
* Changes to the buffer may mutate the original value.
* @param b The bytes object to initialize the buffer with.
* @return A new buffer.
*/
function fromBytes(bytes b) internal pure returns(buffer memory) {
buffer memory buf;
buf.buf = b;
buf.capacity = b.length;
return buf;
}
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
function max(uint a, uint b) private pure returns(uint) {
if (a > b) {
return a;
}
return b;
}
/**
* @dev Sets buffer length to 0.
* @param buf The buffer to truncate.
* @return The original buffer, for chaining..
*/
function truncate(buffer memory buf) internal pure returns (buffer memory) {
assembly {
let bufptr := mload(buf)
mstore(bufptr, 0)
}
return buf;
}
/**
* @dev Writes a byte string to a buffer. Resizes if doing so would exceed
* the capacity of the buffer.
* @param buf The buffer to append to.
* @param off The start offset to write to.
* @param data The data to append.
* @param len The number of bytes to copy.
* @return The original buffer, for chaining.
*/
function write(buffer memory buf, uint off, bytes data, uint len) internal pure returns(buffer memory) {
require(len <= data.length);
if (off + len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len + off) * 2);
}
uint dest;
uint src;
assembly {
// Memory address of the buffer data
let bufptr := mload(buf)
// Length of existing buffer data
let buflen := mload(bufptr)
// Start address = buffer address + offset + sizeof(buffer length)
dest := add(add(bufptr, 32), off)
// Update buffer length if we're extending it
if gt(add(len, off), buflen) {
mstore(bufptr, add(len, off))
}
src := add(data, 32)
}
// Copy word-length chunks while possible
for (; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
return buf;
}
/**
* @dev Appends a byte string to a buffer. Resizes if doing so would exceed
* the capacity of the buffer.
* @param buf The buffer to append to.
* @param data The data to append.
* @param len The number of bytes to copy.
* @return The original buffer, for chaining.
*/
function append(buffer memory buf, bytes data, uint len) internal pure returns (buffer memory) {
return write(buf, buf.buf.length, data, len);
}
/**
* @dev Appends a byte string to a buffer. Resizes if doing so would exceed
* the capacity of the buffer.
* @param buf The buffer to append to.
* @param data The data to append.
* @return The original buffer, for chaining.
*/
function append(buffer memory buf, bytes data) internal pure returns (buffer memory) {
return write(buf, buf.buf.length, data, data.length);
}
/**
* @dev Writes a byte to the buffer. Resizes if doing so would exceed the
* capacity of the buffer.
* @param buf The buffer to append to.
* @param off The offset to write the byte at.
* @param data The data to append.
* @return The original buffer, for chaining.
*/
function writeUint8(buffer memory buf, uint off, uint8 data) internal pure returns(buffer memory) {
if (off > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
// Memory address of the buffer data
let bufptr := mload(buf)
// Length of existing buffer data
let buflen := mload(bufptr)
// Address = buffer address + sizeof(buffer length) + off
let dest := add(add(bufptr, off), 32)
mstore8(dest, data)
// Update buffer length if we extended it
if eq(off, buflen) {
mstore(bufptr, add(buflen, 1))
}
}
return buf;
}
/**
* @dev Appends a byte to the buffer. Resizes if doing so would exceed the
* capacity of the buffer.
* @param buf The buffer to append to.
* @param data The data to append.
* @return The original buffer, for chaining.
*/
function appendUint8(buffer memory buf, uint8 data) internal pure returns(buffer memory) {
return writeUint8(buf, buf.buf.length, data);
}
/**
* @dev Writes up to 32 bytes to the buffer. Resizes if doing so would
* exceed the capacity of the buffer.
* @param buf The buffer to append to.
* @param off The offset to write at.
* @param data The data to append.
* @param len The number of bytes to write (left-aligned).
* @return The original buffer, for chaining.
*/
function write(buffer memory buf, uint off, bytes32 data, uint len) private pure returns(buffer memory) {
if (len + off > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
// Right-align data
data = data >> (8 * (32 - len));
assembly {
// Memory address of the buffer data
let bufptr := mload(buf)
// Address = buffer address + sizeof(buffer length) + off + len
let dest := add(add(bufptr, off), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
// Update buffer length if we extended it
if gt(add(off, len), mload(bufptr)) {
mstore(bufptr, add(off, len))
}
}
return buf;
}
/**
* @dev Writes a bytes20 to the buffer. Resizes if doing so would exceed the
* capacity of the buffer.
* @param buf The buffer to append to.
* @param off The offset to write at.
* @param data The data to append.
* @return The original buffer, for chaining.
*/
function writeBytes20(buffer memory buf, uint off, bytes20 data) internal pure returns (buffer memory) {
return write(buf, off, bytes32(data), 20);
}
/**
* @dev Appends a bytes20 to the buffer. Resizes if doing so would exceed
* the capacity of the buffer.
* @param buf The buffer to append to.
* @param data The data to append.
* @return The original buffer, for chhaining.
*/
function appendBytes20(buffer memory buf, bytes20 data) internal pure returns (buffer memory) {
return write(buf, buf.buf.length, bytes32(data), 20);
}
/**
* @dev Appends a bytes32 to the buffer. Resizes if doing so would exceed
* the capacity of the buffer.
* @param buf The buffer to append to.
* @param data The data to append.
* @return The original buffer, for chaining.
*/
function appendBytes32(buffer memory buf, bytes32 data) internal pure returns (buffer memory) {
return write(buf, buf.buf.length, data, 32);
}
/**
* @dev Writes an integer to the buffer. Resizes if doing so would exceed
* the capacity of the buffer.
* @param buf The buffer to append to.
* @param off The offset to write at.
* @param data The data to append.
* @param len The number of bytes to write (right-aligned).
* @return The original buffer, for chaining.
*/
function writeInt(buffer memory buf, uint off, uint data, uint len) private pure returns(buffer memory) {
if (len + off > buf.capacity) {
resize(buf, max(buf.capacity, len + off) * 2);
}
uint mask = 256 ** len - 1;
assembly {
// Memory address of the buffer data
let bufptr := mload(buf)
// Address = buffer address + off + sizeof(buffer length) + len
let dest := add(add(bufptr, off), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
// Update buffer length if we extended it
if gt(add(off, len), mload(bufptr)) {
mstore(bufptr, add(off, len))
}
}
return buf;
}
}
// File: contracts/RRUtils.sol
/**
* @dev RRUtils is a library that provides utilities for parsing DNS resource records.
*/
library RRUtils {
using BytesUtils for *;
using Buffer for *;
/**
* @dev Returns the number of bytes in the DNS name at 'offset' in 'self'.
* @param self The byte array to read a name from.
* @param offset The offset to start reading at.
* @return The length of the DNS name at 'offset', in bytes.
*/
function nameLength(bytes memory self, uint offset) internal pure returns(uint) {
uint idx = offset;
while (true) {
assert(idx < self.length);
uint labelLen = self.readUint8(idx);
idx += labelLen + 1;
if (labelLen == 0) {
break;
}
}
return idx - offset;
}
/**
* @dev Returns a DNS format name at the specified offset of self.
* @param self The byte array to read a name from.
* @param offset The offset to start reading at.
* @return The name.
*/
function readName(bytes memory self, uint offset) internal pure returns(bytes memory ret) {
uint len = nameLength(self, offset);
return self.substring(offset, len);
}
/**
* @dev Returns the number of labels in the DNS name at 'offset' in 'self'.
* @param self The byte array to read a name from.
* @param offset The offset to start reading at.
* @return The number of labels in the DNS name at 'offset', in bytes.
*/
function labelCount(bytes memory self, uint offset) internal pure returns(uint) {
uint count = 0;
while (true) {
assert(offset < self.length);
uint labelLen = self.readUint8(offset);
offset += labelLen + 1;
if (labelLen == 0) {
break;
}
count += 1;
}
return count;
}
/**
* @dev An iterator over resource records.
*/
struct RRIterator {
bytes data;
uint offset;
uint16 dnstype;
uint16 class;
uint32 ttl;
uint rdataOffset;
uint nextOffset;
}
/**
* @dev Begins iterating over resource records.
* @param self The byte string to read from.
* @param offset The offset to start reading at.
* @return An iterator object.
*/
function iterateRRs(bytes memory self, uint offset) internal pure returns (RRIterator memory ret) {
ret.data = self;
ret.nextOffset = offset;
next(ret);
}
/**
* @dev Returns true iff there are more RRs to iterate.
* @param iter The iterator to check.
* @return True iff the iterator has finished.
*/
function done(RRIterator memory iter) internal pure returns(bool) {
return iter.offset >= iter.data.length;
}
/**
* @dev Moves the iterator to the next resource record.
* @param iter The iterator to advance.
*/
function next(RRIterator memory iter) internal pure {
iter.offset = iter.nextOffset;
if (iter.offset >= iter.data.length) {
return;
}
// Skip the name
uint off = iter.offset + nameLength(iter.data, iter.offset);
// Read type, class, and ttl
iter.dnstype = iter.data.readUint16(off);
off += 2;
iter.class = iter.data.readUint16(off);
off += 2;
iter.ttl = iter.data.readUint32(off);
off += 4;
// Read the rdata
uint rdataLength = iter.data.readUint16(off);
off += 2;
iter.rdataOffset = off;
iter.nextOffset = off + rdataLength;
}
/**
* @dev Returns the name of the current record.
* @param iter The iterator.
* @return A new bytes object containing the owner name from the RR.
*/
function name(RRIterator memory iter) internal pure returns(bytes memory) {
return iter.data.substring(iter.offset, nameLength(iter.data, iter.offset));
}
/**
* @dev Returns the rdata portion of the current record.
* @param iter The iterator.
* @return A new bytes object containing the RR's RDATA.
*/
function rdata(RRIterator memory iter) internal pure returns(bytes memory) {
return iter.data.substring(iter.rdataOffset, iter.nextOffset - iter.rdataOffset);
}
/**
* @dev Checks if a given RR type exists in a type bitmap.
* @param self The byte string to read the type bitmap from.
* @param offset The offset to start reading at.
* @param rrtype The RR type to check for.
* @return True if the type is found in the bitmap, false otherwise.
*/
function checkTypeBitmap(bytes memory self, uint offset, uint16 rrtype) internal pure returns (bool) {
uint8 typeWindow = uint8(rrtype >> 8);
uint8 windowByte = uint8((rrtype & 0xff) / 8);
uint8 windowBitmask = uint8(uint8(1) << (uint8(7) - uint8(rrtype & 0x7)));
for (uint off = offset; off < self.length;) {
uint8 window = self.readUint8(off);
uint8 len = self.readUint8(off + 1);
if (typeWindow < window) {
// We've gone past our window; it's not here.
return false;
} else if (typeWindow == window) {
// Check this type bitmap
if (len * 8 <= windowByte) {
// Our type is past the end of the bitmap
return false;
}
return (self.readUint8(off + windowByte + 2) & windowBitmask) != 0;
} else {
// Skip this type bitmap
off += len + 2;
}
}
return false;
}
function compareNames(bytes memory self, bytes memory other) internal pure returns (int) {
if (self.equals(other)) {
return 0;
}
uint off;
uint otheroff;
uint prevoff;
uint otherprevoff;
uint counts = labelCount(self, 0);
uint othercounts = labelCount(other, 0);
// Keep removing labels from the front of the name until both names are equal length
while (counts > othercounts) {
prevoff = off;
off = progress(self, off);
counts--;
}
while (othercounts > counts) {
otherprevoff = otheroff;
otheroff = progress(other, otheroff);
othercounts--;
}
// Compare the last nonequal labels to each other
while (counts > 0 && !self.equals(off, other, otheroff)) {
prevoff = off;
off = progress(self, off);
otherprevoff = otheroff;
otheroff = progress(other, otheroff);
counts -= 1;
}
if (off == 0) {
return -1;
}
if(otheroff == 0) {
return 1;
}
return self.compare(prevoff + 1, self.readUint8(prevoff), other, otherprevoff + 1, other.readUint8(otherprevoff));
}
function progress(bytes memory body, uint off) internal pure returns(uint) {
return off + 1 + body.readUint8(off);
}
}
// File: contracts/algorithms/Algorithm.sol
/**
* @dev An interface for contracts implementing a DNSSEC (signing) algorithm.
*/
interface Algorithm {
/**
* @dev Verifies a signature.
* @param key The public key to verify with.
* @param data The signed data to verify.
* @param signature The signature to verify.
* @return True iff the signature is valid.
*/
function verify(bytes key, bytes data, bytes signature) external view returns (bool);
}
// File: contracts/digests/Digest.sol
/**
* @dev An interface for contracts implementing a DNSSEC digest.
*/
interface Digest {
/**
* @dev Verifies a cryptographic hash.
* @param data The data to hash.
* @param hash The hash to compare to.
* @return True iff the hashed data matches the provided hash value.
*/
function verify(bytes data, bytes hash) external pure returns (bool);
}
// File: contracts/nsec3digests/NSEC3Digest.sol
/**
* @dev Interface for contracts that implement NSEC3 digest algorithms.
*/
interface NSEC3Digest {
/**
* @dev Performs an NSEC3 iterated hash.
* @param salt The salt value to use on each iteration.
* @param data The data to hash.
* @param iterations The number of iterations to perform.
* @return The result of the iterated hash operation.
*/
function hash(bytes salt, bytes data, uint iterations) external pure returns (bytes32);
}
// File: contracts/DNSSECImpl.sol
/*
* @dev An oracle contract that verifies and stores DNSSEC-validated DNS records.
*
* TODO: Support for NSEC3 records
* TODO: Use 'serial number math' for inception/expiration
*/
contract DNSSECImpl is DNSSEC, Owned {
using Buffer for Buffer.buffer;
using BytesUtils for bytes;
using RRUtils for *;
uint16 constant DNSCLASS_IN = 1;
uint16 constant DNSTYPE_DS = 43;
uint16 constant DNSTYPE_RRSIG = 46;
uint16 constant DNSTYPE_NSEC = 47;
uint16 constant DNSTYPE_DNSKEY = 48;
uint16 constant DNSTYPE_NSEC3 = 50;
uint constant DS_KEY_TAG = 0;
uint constant DS_ALGORITHM = 2;
uint constant DS_DIGEST_TYPE = 3;
uint constant DS_DIGEST = 4;
uint constant RRSIG_TYPE = 0;
uint constant RRSIG_ALGORITHM = 2;
uint constant RRSIG_LABELS = 3;
uint constant RRSIG_TTL = 4;
uint constant RRSIG_EXPIRATION = 8;
uint constant RRSIG_INCEPTION = 12;
uint constant RRSIG_KEY_TAG = 16;
uint constant RRSIG_SIGNER_NAME = 18;
uint constant DNSKEY_FLAGS = 0;
uint constant DNSKEY_PROTOCOL = 2;
uint constant DNSKEY_ALGORITHM = 3;
uint constant DNSKEY_PUBKEY = 4;
uint constant DNSKEY_FLAG_ZONEKEY = 0x100;
uint constant NSEC3_HASH_ALGORITHM = 0;
uint constant NSEC3_FLAGS = 1;
uint constant NSEC3_ITERATIONS = 2;
uint constant NSEC3_SALT_LENGTH = 4;
uint constant NSEC3_SALT = 5;
uint8 constant ALGORITHM_RSASHA256 = 8;
uint8 constant DIGEST_ALGORITHM_SHA256 = 2;
struct RRSet {
uint32 inception;
uint64 inserted;
bytes20 hash;
}
// (name, type) => RRSet
mapping (bytes32 => mapping(uint16 => RRSet)) rrsets;
bytes public anchors;
mapping (uint8 => Algorithm) public algorithms;
mapping (uint8 => Digest) public digests;
mapping (uint8 => NSEC3Digest) public nsec3Digests;
/**
* @dev Constructor.
* @param _anchors The binary format RR entries for the root DS records.
*/
constructor(bytes _anchors) public {
// Insert the 'trust anchors' - the key hashes that start the chain
// of trust for all other records.
anchors = _anchors;
rrsets[keccak256(hex"00")][DNSTYPE_DS] = RRSet({
inception: uint32(0),
inserted: uint64(now),
hash: bytes20(keccak256(anchors))
});
emit RRSetUpdated(hex"00", anchors);
}
/**
* @dev Sets the contract address for a signature verification algorithm.
* Callable only by the owner.
* @param id The algorithm ID
* @param algo The address of the algorithm contract.
*/
function setAlgorithm(uint8 id, Algorithm algo) public owner_only {
algorithms[id] = algo;
emit AlgorithmUpdated(id, algo);
}
/**
* @dev Sets the contract address for a digest verification algorithm.
* Callable only by the owner.
* @param id The digest ID
* @param digest The address of the digest contract.
*/
function setDigest(uint8 id, Digest digest) public owner_only {
digests[id] = digest;
emit DigestUpdated(id, digest);
}
/**
* @dev Sets the contract address for an NSEC3 digest algorithm.
* Callable only by the owner.
* @param id The digest ID
* @param digest The address of the digest contract.
*/
function setNSEC3Digest(uint8 id, NSEC3Digest digest) public owner_only {
nsec3Digests[id] = digest;
emit NSEC3DigestUpdated(id, digest);
}
/**
* @dev Submits multiple RRSets
* @param data The data to submit, as a series of chunks. Each chunk is
* in the format <uint16 length><bytes input><uint16 length><bytes sig>
* @param proof The DNSKEY or DS to validate the first signature against.
* @return The last RRSET submitted.
*/
function submitRRSets(bytes memory data, bytes memory proof) public returns (bytes) {
uint offset = 0;
while(offset < data.length) {
bytes memory input = data.substring(offset + 2, data.readUint16(offset));
offset += input.length + 2;
bytes memory sig = data.substring(offset + 2, data.readUint16(offset));
offset += sig.length + 2;
proof = submitRRSet(input, sig, proof);
}
return proof;
}
/**
* @dev Submits a signed set of RRs to the oracle.
*
* RRSETs are only accepted if they are signed with a key that is already
* trusted, or if they are self-signed, and the signing key is identified by
* a DS record that is already trusted.
*
* @param input The signed RR set. This is in the format described in section
* 5.3.2 of RFC4035: The RRDATA section from the RRSIG without the signature
* data, followed by a series of canonicalised RR records that the signature
* applies to.
* @param sig The signature data from the RRSIG record.
* @param proof The DNSKEY or DS to validate the signature against. Must Already
* have been submitted and proved previously.
*/
function submitRRSet(bytes memory input, bytes memory sig, bytes memory proof)
public returns(bytes memory rrs)
{
bytes memory name;
(name, rrs) = validateSignedSet(input, sig, proof);
uint32 inception = input.readUint32(RRSIG_INCEPTION);
uint16 typecovered = input.readUint16(RRSIG_TYPE);
RRSet storage set = rrsets[keccak256(name)][typecovered];
if (set.inserted > 0) {
// To replace an existing rrset, the signature must be at least as new
require(inception >= set.inception);
}
if (set.hash == keccak256(rrs)) {
// Already inserted!
return;
}
rrsets[keccak256(name)][typecovered] = RRSet({
inception: inception,
inserted: uint64(now),
hash: bytes20(keccak256(rrs))
});
emit RRSetUpdated(name, rrs);
}
/**
* @dev Deletes an RR from the oracle.
*
* @param deleteType The DNS record type to delete.
* @param deleteName which you want to delete
* @param nsec The signed NSEC RRset. This is in the format described in section
* 5.3.2 of RFC4035: The RRDATA section from the RRSIG without the signature
* data, followed by a series of canonicalised RR records that the signature
* applies to.
*/
function deleteRRSet(uint16 deleteType, bytes deleteName, bytes memory nsec, bytes memory sig, bytes memory proof) public {
bytes memory nsecName;
bytes memory rrs;
(nsecName, rrs) = validateSignedSet(nsec, sig, proof);
// Don't let someone use an old proof to delete a new name
require(rrsets[keccak256(deleteName)][deleteType].inception <= nsec.readUint32(RRSIG_INCEPTION));
for (RRUtils.RRIterator memory iter = rrs.iterateRRs(0); !iter.done(); iter.next()) {
// We're dealing with three names here:
// - deleteName is the name the user wants us to delete
// - nsecName is the owner name of the NSEC record
// - nextName is the next name specified in the NSEC record
//
// And three cases:
// - deleteName equals nsecName, in which case we can delete the
// record if it's not in the type bitmap.
// - nextName comes after nsecName, in which case we can delete
// the record if deleteName comes between nextName and nsecName.
// - nextName comes before nsecName, in which case nextName is the
// zone apez, and deleteName must come after nsecName.
if(iter.dnstype == DNSTYPE_NSEC) {
checkNsecName(iter, nsecName, deleteName, deleteType);
} else if(iter.dnstype == DNSTYPE_NSEC3) {
checkNsec3Name(iter, nsecName, deleteName, deleteType);
} else {
revert("Unrecognised record type");
}
delete rrsets[keccak256(deleteName)][deleteType];
return;
}
// This should never reach.
revert();
}
function checkNsecName(RRUtils.RRIterator memory iter, bytes memory nsecName, bytes memory deleteName, uint16 deleteType) private pure {
uint rdataOffset = iter.rdataOffset;
uint nextNameLength = iter.data.nameLength(rdataOffset);
uint rDataLength = iter.nextOffset - iter.rdataOffset;
// We assume that there is always typed bitmap after the next domain name
require(rDataLength > nextNameLength);
int compareResult = deleteName.compareNames(nsecName);
if(compareResult == 0) {
// Name to delete is on the same label as the NSEC record
require(!iter.data.checkTypeBitmap(rdataOffset + nextNameLength, deleteType));
} else {
// First check if the NSEC next name comes after the NSEC name.
bytes memory nextName = iter.data.substring(rdataOffset,nextNameLength);
// deleteName must come after nsecName
require(compareResult > 0);
if(nsecName.compareNames(nextName) < 0) {
// deleteName must also come before nextName
require(deleteName.compareNames(nextName) < 0);
}
}
}
function checkNsec3Name(RRUtils.RRIterator memory iter, bytes memory nsecName, bytes memory deleteName, uint16 deleteType) private view {
uint16 iterations = iter.data.readUint16(iter.rdataOffset + NSEC3_ITERATIONS);
uint8 saltLength = iter.data.readUint8(iter.rdataOffset + NSEC3_SALT_LENGTH);
bytes memory salt = iter.data.substring(iter.rdataOffset + NSEC3_SALT, saltLength);
bytes32 deleteNameHash = nsec3Digests[iter.data.readUint8(iter.rdataOffset)].hash(salt, deleteName, iterations);
uint8 nextLength = iter.data.readUint8(iter.rdataOffset + NSEC3_SALT + saltLength);
require(nextLength <= 32);
bytes32 nextNameHash = iter.data.readBytesN(iter.rdataOffset + NSEC3_SALT + saltLength + 1, nextLength);
bytes32 nsecNameHash = nsecName.base32HexDecodeWord(1, uint(nsecName.readUint8(0)));
if(deleteNameHash == nsecNameHash) {
// Name to delete is on the same label as the NSEC record
require(!iter.data.checkTypeBitmap(iter.rdataOffset + NSEC3_SALT + saltLength + 1 + nextLength, deleteType));
} else {
// deleteName must come after nsecName
require(deleteNameHash > nsecNameHash);
// Check if the NSEC next name comes after the NSEC name.
if(nextNameHash > nsecNameHash) {
// deleteName must come also come before nextName
require(deleteNameHash < nextNameHash);
}
}
}
/**
* @dev Returns data about the RRs (if any) known to this oracle with the provided type and name.
* @param dnstype The DNS record type to query.
* @param name The name to query, in DNS label-sequence format.
* @return inception The unix timestamp at which the signature for this RRSET was created.
* @return inserted The unix timestamp at which this RRSET was inserted into the oracle.
* @return hash The hash of the RRset that was inserted.
*/
function rrdata(uint16 dnstype, bytes memory name) public view returns (uint32, uint64, bytes20) {
RRSet storage result = rrsets[keccak256(name)][dnstype];
return (result.inception, result.inserted, result.hash);
}
/**
* @dev Submits a signed set of RRs to the oracle.
*
* RRSETs are only accepted if they are signed with a key that is already
* trusted, or if they are self-signed, and the signing key is identified by
* a DS record that is already trusted.
*
* @param input The signed RR set. This is in the format described in section
* 5.3.2 of RFC4035: The RRDATA section from the RRSIG without the signature
* data, followed by a series of canonicalised RR records that the signature
* applies to.
* @param sig The signature data from the RRSIG record.
* @param proof The DNSKEY or DS to validate the signature against. Must Already
* have been submitted and proved previously.
*/
function validateSignedSet(bytes memory input, bytes memory sig, bytes memory proof) internal view returns(bytes memory name, bytes memory rrs) {
require(validProof(input.readName(RRSIG_SIGNER_NAME), proof));
uint32 inception = input.readUint32(RRSIG_INCEPTION);
uint32 expiration = input.readUint32(RRSIG_EXPIRATION);
uint16 typecovered = input.readUint16(RRSIG_TYPE);
uint8 labels = input.readUint8(RRSIG_LABELS);
// Extract the RR data
uint rrdataOffset = input.nameLength(RRSIG_SIGNER_NAME) + 18;
rrs = input.substring(rrdataOffset, input.length - rrdataOffset);
// Do some basic checks on the RRs and extract the name
name = validateRRs(rrs, typecovered);
require(name.labelCount(0) == labels);
// TODO: Check inception and expiration using mod2^32 math
// o The validator's notion of the current time MUST be less than or
// equal to the time listed in the RRSIG RR's Expiration field.
require(expiration > now);
// o The validator's notion of the current time MUST be greater than or
// equal to the time listed in the RRSIG RR's Inception field.
require(inception < now);
// Validate the signature
verifySignature(name, input, sig, proof);
return (name, rrs);
}
function validProof(bytes name, bytes memory proof) internal view returns(bool) {
uint16 dnstype = proof.readUint16(proof.nameLength(0));
return rrsets[keccak256(name)][dnstype].hash == bytes20(keccak256(proof));
}
/**
* @dev Validates a set of RRs.
* @param data The RR data.
* @param typecovered The type covered by the RRSIG record.
*/
function validateRRs(bytes memory data, uint16 typecovered) internal pure returns (bytes memory name) {
// Iterate over all the RRs
for (RRUtils.RRIterator memory iter = data.iterateRRs(0); !iter.done(); iter.next()) {
// We only support class IN (Internet)
require(iter.class == DNSCLASS_IN);
if(name.length == 0) {
name = iter.name();
} else {
// Name must be the same on all RRs
require(name.length == data.nameLength(iter.offset));
require(name.equals(0, data, iter.offset, name.length));
}
// o The RRSIG RR's Type Covered field MUST equal the RRset's type.
require(iter.dnstype == typecovered);
}
}
/**
* @dev Performs signature verification.
*
* Throws or reverts if unable to verify the record.
*
* @param name The name of the RRSIG record, in DNS label-sequence format.
* @param data The original data to verify.
* @param sig The signature data.
*/
function verifySignature(bytes name, bytes memory data, bytes memory sig, bytes memory proof) internal view {
uint signerNameLength = data.nameLength(RRSIG_SIGNER_NAME);
// o The RRSIG RR's Signer's Name field MUST be the name of the zone
// that contains the RRset.
require(signerNameLength <= name.length);
require(data.equals(RRSIG_SIGNER_NAME, name, name.length - signerNameLength, signerNameLength));
// Set the return offset to point at the first RR
uint offset = 18 + signerNameLength;
// Check the proof
uint16 dnstype = proof.readUint16(proof.nameLength(0));
if (dnstype == DNSTYPE_DS) {
require(verifyWithDS(data, sig, offset, proof));
} else if (dnstype == DNSTYPE_DNSKEY) {
require(verifyWithKnownKey(data, sig, proof));
} else {
revert("Unsupported proof record type");
}
}
/**
* @dev Attempts to verify a signed RRSET against an already known public key.
* @param data The original data to verify.
* @param sig The signature data.
* @return True if the RRSET could be verified, false otherwise.
*/
function verifyWithKnownKey(bytes memory data, bytes memory sig, bytes memory proof) internal view returns(bool) {
uint signerNameLength = data.nameLength(RRSIG_SIGNER_NAME);
// Extract algorithm and keytag
uint8 algorithm = data.readUint8(RRSIG_ALGORITHM);
uint16 keytag = data.readUint16(RRSIG_KEY_TAG);
for (RRUtils.RRIterator memory iter = proof.iterateRRs(0); !iter.done(); iter.next()) {
// Check the DNSKEY's owner name matches the signer name on the RRSIG
require(proof.nameLength(0) == signerNameLength);
require(proof.equals(0, data, RRSIG_SIGNER_NAME, signerNameLength));
if (verifySignatureWithKey(iter.rdata(), algorithm, keytag, data, sig)) {
return true;
}
}
return false;
}
/**
* @dev Attempts to verify a signed RRSET against an already known public key.
* @param data The original data to verify.
* @param sig The signature data.
* @param offset The offset from the start of the data to the first RR.
* @return True if the RRSET could be verified, false otherwise.
*/
function verifyWithDS(bytes memory data, bytes memory sig, uint offset, bytes memory proof) internal view returns(bool) {
// Extract algorithm and keytag
uint8 algorithm = data.readUint8(RRSIG_ALGORITHM);
uint16 keytag = data.readUint16(RRSIG_KEY_TAG);
// Perhaps it's self-signed and verified by a DS record?
for (RRUtils.RRIterator memory iter = data.iterateRRs(offset); !iter.done(); iter.next()) {
if (iter.dnstype != DNSTYPE_DNSKEY) {
return false;
}
bytes memory keyrdata = iter.rdata();
if (verifySignatureWithKey(keyrdata, algorithm, keytag, data, sig)) {
// It's self-signed - look for a DS record to verify it.
return verifyKeyWithDS(iter.name(), keyrdata, keytag, algorithm, proof);
}
}
return false;
}
/**
* @dev Attempts to verify some data using a provided key and a signature.
* @param keyrdata The RDATA section of the key to use.
* @param algorithm The algorithm ID of the key and signature.
* @param keytag The keytag from the signature.
* @param data The data to verify.
* @param sig The signature to use.
* @return True iff the key verifies the signature.
*/
function verifySignatureWithKey(bytes memory keyrdata, uint8 algorithm, uint16 keytag, bytes data, bytes sig) internal view returns (bool) {
if (algorithms[algorithm] == address(0)) {
return false;
}
// TODO: Check key isn't expired, unless updating key itself
// o The RRSIG RR's Signer's Name, Algorithm, and Key Tag fields MUST
// match the owner name, algorithm, and key tag for some DNSKEY RR in
// the zone's apex DNSKEY RRset.
if (keyrdata.readUint8(DNSKEY_PROTOCOL) != 3) {
return false;
}
if (keyrdata.readUint8(DNSKEY_ALGORITHM) != algorithm) {
return false;
}
uint16 computedkeytag = computeKeytag(keyrdata);
if (computedkeytag != keytag) {
return false;
}
// o The matching DNSKEY RR MUST be present in the zone's apex DNSKEY
// RRset, and MUST have the Zone Flag bit (DNSKEY RDATA Flag bit 7)
// set.
if (keyrdata.readUint16(DNSKEY_FLAGS) & DNSKEY_FLAG_ZONEKEY == 0) {
return false;
}
return algorithms[algorithm].verify(keyrdata, data, sig);
}
/**
* @dev Attempts to verify a key using DS records.
* @param keyname The DNS name of the key, in DNS label-sequence format.
* @param keyrdata The RDATA section of the key.
* @param keytag The keytag of the key.
* @param algorithm The algorithm ID of the key.
* @return True if a DS record verifies this key.
*/
function verifyKeyWithDS(bytes memory keyname, bytes memory keyrdata, uint16 keytag, uint8 algorithm, bytes memory data)
internal view returns (bool)
{
for (RRUtils.RRIterator memory iter = data.iterateRRs(0); !iter.done(); iter.next()) {
if (data.readUint16(iter.rdataOffset + DS_KEY_TAG) != keytag) {
continue;
}
if (data.readUint8(iter.rdataOffset + DS_ALGORITHM) != algorithm) {
continue;
}
uint8 digesttype = data.readUint8(iter.rdataOffset + DS_DIGEST_TYPE);
Buffer.buffer memory buf;
buf.init(keyname.length + keyrdata.length);
buf.append(keyname);
buf.append(keyrdata);
if (verifyDSHash(digesttype, buf.buf, data.substring(iter.rdataOffset, iter.nextOffset - iter.rdataOffset))) {
return true;
}
}
return false;
}
/**
* @dev Attempts to verify a DS record's hash value against some data.
* @param digesttype The digest ID from the DS record.
* @param data The data to digest.
* @param digest The digest data to check against.
* @return True iff the digest matches.
*/
function verifyDSHash(uint8 digesttype, bytes data, bytes digest) internal view returns (bool) {
if (digests[digesttype] == address(0)) {
return false;
}
return digests[digesttype].verify(data, digest.substring(4, digest.length - 4));
}
/**
* @dev Computes the keytag for a chunk of data.
* @param data The data to compute a keytag for.
* @return The computed key tag.
*/
function computeKeytag(bytes memory data) internal pure returns (uint16) {
uint ac;
for (uint i = 0; i < data.length; i += 2) {
ac += data.readUint16(i);
}
ac += (ac >> 16) & 0xFFFF;
return uint16(ac & 0xFFFF);
}
} | * @dev Sets the contract address for a signature verification algorithm. Callable only by the owner. @param id The algorithm ID @param algo The address of the algorithm contract./ | function setAlgorithm(uint8 id, Algorithm algo) public owner_only {
algorithms[id] = algo;
emit AlgorithmUpdated(id, algo);
}
| 12,747,729 | [
1,
2785,
326,
6835,
1758,
364,
279,
3372,
11805,
4886,
18,
1377,
10464,
1338,
635,
326,
3410,
18,
225,
612,
1021,
4886,
1599,
225,
13901,
1021,
1758,
434,
326,
4886,
6835,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
444,
6801,
12,
11890,
28,
612,
16,
15067,
13901,
13,
1071,
3410,
67,
3700,
288,
203,
3639,
20032,
63,
350,
65,
273,
13901,
31,
203,
3639,
3626,
15067,
7381,
12,
350,
16,
13901,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/43113/0xF97FA6A8b0407deddE2336eA98Bc688b34901c52/sources/project_/contracts/Twenty6Fifty2.sol | @title Twenty6Fifty2 @author lileddie.eth / Enefte Studio/ | contract Twenty6Fifty2 is ERC721A, EnefteOwnership {
uint64 public MAX_SUPPLY = 2652;
uint64 public TOKEN_PRICE = 0.01 ether;
uint64 public MAX_TOKENS_PER_WALLET = 1000;
uint64 public EMISSIONS = 91000;
uint64 public SALE_OPENS = 0;
uint64 public SALE_CLOSES = 999999999999;
INinety1 NINETY_ONE;
IFold FOLD;
IFoldStaking foldStaking;
mapping(uint => uint) handMultiplier;
bool LOCKED = false;
modifier notLocked() {
require(!LOCKED, "Contract locked.");
_;
}
function mint(uint64 _numberOfTokens) external payable {
require(block.timestamp >= SALE_OPENS && block.timestamp <= SALE_CLOSES, "Public sale closed");
require(totalSupply() + _numberOfTokens <= MAX_SUPPLY, "Not enough left");
uint64 mintsForThisWallet = mintsForWallet(msg.sender);
mintsForThisWallet += _numberOfTokens;
require(mintsForThisWallet <= MAX_TOKENS_PER_WALLET, "Max tokens reached per wallet");
require(TOKEN_PRICE * _numberOfTokens <= msg.value, 'Missing eth');
_safeMint(msg.sender, _numberOfTokens);
FOLD.mint(EMISSIONS*_numberOfTokens);
_setAux(msg.sender,mintsForThisWallet);
}
function fold(uint _tokenId) external {
require(ownerOf(_tokenId) == msg.sender, "Not your token");
NINETY_ONE.mint(msg.sender);
FOLD.transfer(address(NINETY_ONE),EMISSIONS);
_burn(_tokenId);
}
function setMultipliers(uint[] calldata _tokenIds, uint _tier) external onlyOwner notLocked {
for (uint256 i = 0; i < _tokenIds.length; i++) {
handMultiplier[_tokenIds[i]] = _tier;
}
}
function setMultipliers(uint[] calldata _tokenIds, uint _tier) external onlyOwner notLocked {
for (uint256 i = 0; i < _tokenIds.length; i++) {
handMultiplier[_tokenIds[i]] = _tier;
}
}
function mintsForWallet(address _wallet) public view returns (uint64) {
return _getAux(_wallet);
}
function setSaleTimes(uint64 _openTime, uint64 _closeTime) external onlyOwner notLocked {
SALE_OPENS = _openTime;
SALE_CLOSES = _closeTime;
}
function setMaxPerWallet(uint64 _quantity) external onlyOwner notLocked {
MAX_TOKENS_PER_WALLET = _quantity;
}
function setBaseURI(string memory _uri) external onlyOwner notLocked {
BASE_URI = _uri;
}
function set91(address _address) external onlyOwner notLocked {
NINETY_ONE = INinety1(_address);
}
function setFold(address _address) external onlyOwner notLocked {
FOLD = IFold(_address);
}
function setFoldStaking(address _address) external onlyOwner notLocked {
foldStaking = IFoldStaking(_address);
}
function _baseURI() internal view override returns (string memory) {
return BASE_URI;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
string memory baseURI = _baseURI();
return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : '';
}
function withdrawBalance() external onlyOwner {
uint256 balance = address(this).balance;
require(sent, "Failed to send Ether to Wallet");
}
(bool sent, bytes memory data) = msg.sender.call{value: balance}("");
function calculateEmissions(uint256 _firstTokenId, uint256 _quantity) internal view returns (uint256 totalEmissions) {
uint _emissions = 0;
for(uint i = 0;i < _quantity;i++){
uint tokenId = _firstTokenId + i;
uint multiplier = handMultiplier[tokenId];
_emissions += EMISSIONS * multiplier;
}
return _emissions;
}
function calculateEmissions(uint256 _firstTokenId, uint256 _quantity) internal view returns (uint256 totalEmissions) {
uint _emissions = 0;
for(uint i = 0;i < _quantity;i++){
uint tokenId = _firstTokenId + i;
uint multiplier = handMultiplier[tokenId];
_emissions += EMISSIONS * multiplier;
}
return _emissions;
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
uint256 totalEmissions = calculateEmissions(startTokenId,quantity);
if(from == address(0)){
foldStaking.deposit(totalEmissions,to);
}
else if(to == address(0)){
foldStaking.withdraw(totalEmissions,from);
}
else if(from == address(0)){
foldStaking.withdraw(totalEmissions,from);
foldStaking.deposit(totalEmissions,to);
}
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
uint256 totalEmissions = calculateEmissions(startTokenId,quantity);
if(from == address(0)){
foldStaking.deposit(totalEmissions,to);
}
else if(to == address(0)){
foldStaking.withdraw(totalEmissions,from);
}
else if(from == address(0)){
foldStaking.withdraw(totalEmissions,from);
foldStaking.deposit(totalEmissions,to);
}
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
uint256 totalEmissions = calculateEmissions(startTokenId,quantity);
if(from == address(0)){
foldStaking.deposit(totalEmissions,to);
}
else if(to == address(0)){
foldStaking.withdraw(totalEmissions,from);
}
else if(from == address(0)){
foldStaking.withdraw(totalEmissions,from);
foldStaking.deposit(totalEmissions,to);
}
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
uint256 totalEmissions = calculateEmissions(startTokenId,quantity);
if(from == address(0)){
foldStaking.deposit(totalEmissions,to);
}
else if(to == address(0)){
foldStaking.withdraw(totalEmissions,from);
}
else if(from == address(0)){
foldStaking.withdraw(totalEmissions,from);
foldStaking.deposit(totalEmissions,to);
}
}
function lockContract() external onlyOwner notLocked {
LOCKED = true;
}
function _startTokenId() internal override view virtual returns (uint256) {
return 1;
}
constructor() ERC721A("Twenty6Fifty2", "2652") {
setOwner(msg.sender);
}
} | 7,209,116 | [
1,
23539,
319,
93,
26,
42,
2136,
93,
22,
225,
328,
398,
449,
1385,
18,
546,
342,
1374,
10241,
736,
934,
4484,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
12694,
319,
93,
26,
42,
2136,
93,
22,
353,
4232,
39,
27,
5340,
37,
16,
1374,
10241,
736,
5460,
12565,
288,
203,
203,
565,
2254,
1105,
1071,
4552,
67,
13272,
23893,
273,
576,
9222,
22,
31,
203,
565,
2254,
1105,
1071,
14275,
67,
7698,
1441,
273,
374,
18,
1611,
225,
2437,
31,
203,
565,
2254,
1105,
1071,
4552,
67,
8412,
55,
67,
3194,
67,
59,
1013,
15146,
273,
4336,
31,
203,
565,
2254,
1105,
1071,
7141,
45,
4475,
55,
273,
2468,
18088,
31,
203,
203,
565,
2254,
1105,
1071,
17127,
900,
67,
11437,
55,
273,
374,
31,
203,
565,
2254,
1105,
1071,
17127,
900,
67,
13384,
55,
273,
23841,
7991,
11984,
31,
7010,
203,
565,
2120,
267,
14369,
21,
423,
18819,
61,
67,
5998,
31,
7010,
565,
11083,
1673,
478,
11846,
31,
203,
565,
11083,
1673,
510,
6159,
11590,
510,
6159,
31,
203,
203,
565,
2874,
12,
11890,
516,
2254,
13,
948,
23365,
31,
203,
203,
565,
1426,
14631,
2056,
273,
629,
31,
203,
377,
203,
203,
565,
9606,
486,
8966,
1435,
288,
203,
3639,
2583,
12,
5,
6589,
2056,
16,
315,
8924,
8586,
1199,
1769,
203,
3639,
389,
31,
203,
565,
289,
203,
203,
377,
203,
565,
445,
312,
474,
12,
11890,
1105,
389,
2696,
951,
5157,
13,
3903,
8843,
429,
288,
203,
3639,
2583,
12,
2629,
18,
5508,
1545,
17127,
900,
67,
11437,
55,
597,
1203,
18,
5508,
1648,
17127,
900,
67,
13384,
55,
16,
315,
4782,
272,
5349,
4375,
8863,
203,
3639,
2583,
12,
4963,
3088,
1283,
1435,
397,
389,
2
] |
./partial_match/1/0x659870BC166590fb369F33e62a55647A40cd2c09/sources/OCOCToken.sol | Set the token symbol for display
| string private constant symbol_ = 'OCOC'; | 4,483,915 | [
1,
694,
326,
1147,
3273,
364,
2562,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
225,
533,
3238,
5381,
3273,
67,
273,
296,
51,
3865,
39,
13506,
4766,
1850,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
/**
*Submitted for verification at Etherscan.io on 2021-05-06
*/
pragma solidity ^0.6.3;
/*
* @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;
}
}
/**
* @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.
*/
abstract 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;
}
}
/**
* @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 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;
}
}
/**
* @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) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
/**
* @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");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
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);
}
}
}
}
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Destructor is Ownable {
bool public destructing;
modifier onlyBeforeDestruct() {
require(!destructing, "pre destory...");
_;
}
modifier onlyDestructing() {
require(destructing, "destorying...");
_;
}
function preDestruct() onlyOwner onlyBeforeDestruct public {
destructing = true;
}
function destructERC20(address _erc20, uint256 _amount) onlyOwner onlyDestructing public {
if (_amount == 0) {
_amount = IERC20(_erc20).balanceOf(address(this));
}
require(_amount > 0, "check balance");
IERC20(_erc20).transfer(owner(), _amount);
}
function destory() onlyOwner onlyDestructing public {
selfdestruct(address(uint160(owner())));
}
}
abstract contract Operable is Ownable {
address public operator;
event OperatorUpdated(address indexed previous, address indexed newOperator);
constructor(address _operator) public {
if (_operator == address(0)) {
operator = msg.sender;
} else {
operator = _operator;
}
}
modifier onlyOperator() {
require(operator == msg.sender, "Operable: caller is not the operator");
_;
}
function updateOperator(address newOperator) public onlyOwner {
require(newOperator != address(0), "Operable: new operator is the zero address");
emit OperatorUpdated(operator, newOperator);
operator = newOperator;
}
}
interface IMigratorChef {
// Perform LP token migration from legacy UniswapV2 to SushiSwap.
// Take the current LP token address and return the new LP token address.
// Migrator should have full access to the caller's LP token.
// Return the new LP token address.
//
// XXX Migrator must have allowance access to UniswapV2 LP tokens.
// SushiSwap must mint EXACTLY the same amount of SushiSwap LP tokens or
// else something bad will happen. Traditional UniswapV2 does not
// do that so be careful!
function migrate(IERC20 token) external returns (IERC20);
}
interface Mintable {
function mint(address account, uint256 amount) external returns (bool);
}
interface IMintProxy {
function mint(address account, uint256 amount, uint8 tp) external returns (bool);
}
contract TmpMintProxy is IMintProxy, Operable, Destructor {
using SafeERC20 for IERC20;
event Mint(address indexed user, uint8 indexed tp, uint256 amount);
IERC20 public token;
constructor(IERC20 _token) Operable(address(0)) public {
token = _token;
}
// mint for deposit lp token
function mint(address account, uint256 amount, uint8 tp) onlyOperator onlyBeforeDestruct override public returns (bool){
require(account != address(0), "mint to the zero address");
IERC20(token).safeTransfer(account, amount);
emit Mint(account, tp, amount);
return true;
}
}
abstract contract Reward is Ownable {
using SafeMath for uint256;
uint256 private dayRewardAmount;
mapping(address => uint256) rewardDetails;
address[] rewardAddr;
uint32 public lastMintDayTime;
uint32 public units;
event Mint(uint32 time, uint256 amount);
constructor() public {
units = 86400;
}
function updateUnits(uint32 _units) onlyOwner public{
units = _units;
}
// update lastDayTime
function refreshMintDay() internal returns(uint16) {
uint32 _units = units;
uint32 _dayTime = ( uint32(now) / _units ) * _units;
require(_dayTime>lastMintDayTime, "day time check");
lastMintDayTime = _dayTime;
}
function clearReward() private {
uint _addrsLength = rewardAddr.length;
for (uint i=0; i< _addrsLength; i++) {
delete rewardDetails[rewardAddr[i]];
}
delete rewardAddr;
}
function mint() internal {
// clear reward
clearReward();
address[] memory _addrs;
uint256[] memory _amounts;
uint256 _total;
(_addrs, _amounts, _total) = mintInfo();
require(_addrs.length == _amounts.length, "check length");
require(_total > 0, "check total");
uint256 _rewardAmount = getRewardAmount();
uint _addrsLength = _addrs.length;
for (uint i=0; i< _addrsLength; i++) {
require(_addrs[i]!=address(0), "check address");
require(_amounts[i]>0, "check amount");
rewardDetails[_addrs[i]] = _amounts[i].mul(_rewardAmount).div(_total);
rewardAddr.push(_addrs[i]);
}
emit Mint(lastMintDayTime, _rewardAmount);
}
function withdraw() public {
uint256 _amount = rewardDetails[msg.sender];
require(_amount>0, "check reward amount");
// clear
rewardDetails[msg.sender] = 0;
transferTo(msg.sender, _amount);
}
function myReward(address addr) public view returns(uint256){
return rewardDetails[addr];
}
function withdrawInfo() public view returns(uint32, address[] memory, uint256[] memory, uint256) {
uint256[] memory _amounts = new uint256[](rewardAddr.length);
uint256 _total = 0;
uint _arrLength = rewardAddr.length;
for (uint i=0; i< _arrLength; i++) {
uint256 amount = rewardDetails[rewardAddr[i]];
_total = _total.add(amount);
_amounts[i] = amount;
}
return (lastMintDayTime, rewardAddr, _amounts, _total);
}
function transferTo(address _to, uint256 _amount) internal virtual;
function getRewardAmount() public view virtual returns (uint256);
function mintInfo() public view virtual returns(address[] memory, uint256[] memory, uint256);
}
abstract contract RewardERC20 is Reward {
uint256 private dayRewardAmount;
address public rewardToken;
constructor(address _rewardToken, uint256 _dayRewardAmount) public {
dayRewardAmount = _dayRewardAmount;
rewardToken = _rewardToken;
}
function updateRewardAmount(uint256 _amount) onlyOwner public {
dayRewardAmount = _amount;
}
function getRewardAmount() public view override returns (uint256) {
return dayRewardAmount;
}
function transferTo(address _to, uint256 _amount) internal override {
// transfer erc20 token
IERC20(rewardToken).transfer(_to, _amount);
}
}
interface ILiquidity {
function emitJoin(address _taker, uint256 _ethVal) external;
}
contract LiquidityStats is Ownable {
using SafeMath for uint256;
mapping(address=>uint8) public factoryOwnerMap;
address public clearOwner;
mapping ( address => uint256 ) public takerValueMap;
address[] public takerArr;
uint256 public threshold;
constructor(address[] memory _factorys, uint256 _threshold) public {
uint _arrLength = _factorys.length;
for (uint i=0; i< _arrLength; i++) {
factoryOwnerMap[_factorys[i]] = 1;
}
threshold = _threshold;
}
function updateFactoryOwner(address[] memory _addrs, uint8[] memory _vals) onlyOwner public {
uint _arrLength = _addrs.length;
for (uint i=0; i< _arrLength; i++) {
factoryOwnerMap[_addrs[i]] = _vals[i];
}
}
function updateThreshold(uint256 _threshold) onlyOwner public {
threshold = _threshold;
}
function updateClearOwner(address _addr) onlyOwner public {
clearOwner = _addr;
}
function emitJoin(address _taker, uint256 _ethVal) public {
require(factoryOwnerMap[msg.sender]>0, "factory address check");
if(_ethVal>=threshold){
uint256 prev = takerValueMap[_taker];
if (prev == 0) {
takerArr.push(_taker);
}
takerValueMap[_taker] = prev.add(1);
}
}
function clear() public {
require(msg.sender == clearOwner, "clear owner address check");
uint _arrLength = takerArr.length;
for (uint i=0; i< _arrLength; i++) {
delete takerValueMap[takerArr[i]];
}
delete takerArr;
}
function stats() public view returns(address[] memory, uint256[] memory, uint256) {
uint256[] memory _amounts = new uint256[](takerArr.length);
uint256 _total = 0;
uint _arrLength = takerArr.length;
for (uint i=0; i< _arrLength; i++) {
uint256 amount = takerValueMap[takerArr[i]];
_total = _total.add(amount);
_amounts[i] = amount;
}
return (takerArr, _amounts, _total);
}
}
interface IStats {
function stats() external view returns(address[] memory, uint256[] memory, uint256);
function clear() external;
}
contract LiquidityMiner is Operable, RewardERC20, Destructor {
address public liquidityStatsAddr;
constructor(address _rewardToken, uint256 _dayRewardAmount, address _statsAddr, address _operatorAddr) Operable(_operatorAddr) RewardERC20(_rewardToken,_dayRewardAmount) public {
liquidityStatsAddr = _statsAddr;
}
function updateStatsAddr(address _addr) onlyOwner public {
require(_addr!=liquidityStatsAddr, "check stats address");
require(_addr!=address(0), "check stats address 0");
liquidityStatsAddr = _addr;
}
function liquidityMint() onlyOperator onlyBeforeDestruct public{
// mint
mint();
// clear
IStats(liquidityStatsAddr).clear();
}
function mintInfo() public view override returns(address[] memory, uint256[] memory, uint256) {
return IStats(liquidityStatsAddr).stats();
}
}
interface IStaking {
function hastaked(address _who) external returns(bool);
function stats() external view returns(address[] memory, uint256[] memory, uint256);
function clear() external;
}
interface IFee {
function emitFee(address _addr, uint256 _ethVal) payable external;
}
contract FeeStats {
event Fee(address _addr, uint256 _ethVal);
function emitFee(address _addr, uint256 _ethVal) payable public {
require(_ethVal==msg.value, "fee value");
emit Fee(_addr, _ethVal);
}
}
interface Events {
event CreatePool(uint32 indexed id, address indexed maker, bool priv, address tracker, uint256 amount, uint256 rate, uint256 units);
event Join(uint32 indexed id, address indexed taker, bool priv, uint256 ethAmount, address tracker, uint256 amount);
event Withdraw(uint32 indexed id, address indexed sender, uint256 amount, uint32 tp);
event Close(uint32 indexed id, bool priv);
}
contract AbstractFactory is Ownable {
address public liquidtyAddr;
address public stakeAddr;
address public feeAddr;
uint32 public constant takerFeeBase = 100000;
uint32 public takerFeeRate;
uint256 public makerFixedFee;
constructor() public {
takerFeeRate = 0;
makerFixedFee = 0;
}
modifier makerFee() {
if(makerFixedFee>0) {
require(msg.value >= makerFixedFee, "check maker fee, fee must be le value");
require(feeAddr!=address(0), "check fee address, fail");
// transfer fee to owner
IFee(feeAddr).emitFee{value:makerFixedFee}(msg.sender, makerFixedFee);
}
_;
}
modifier takerFee(uint256 _value) {
require(_value>0, "check taker value, value must be gt 0");
uint256 _fee = 0;
if(takerFeeRate>0){
_fee = _value * takerFeeRate / takerFeeBase;
require(_fee > 0, "check taker fee, fee must be gt 0");
require(_fee < _value, "check taker fee, fee must be le value");
require(feeAddr!=address(0), "check fee address, fail");
// transfer fee to owner
IFee(feeAddr).emitFee{value:_fee}(msg.sender, _fee);
}
require(_value+_fee<=msg.value,"check taker fee and value, total must be le value");
_;
}
function joinPoolAfter(address _taker, uint256 _ethVal) internal {
if(liquidtyAddr!=address(0)){
ILiquidity(liquidtyAddr).emitJoin(_taker, _ethVal);
}
}
function updateTakerFeeRate(uint32 _rate) public onlyOwner {
takerFeeRate = _rate;
}
function updateMakerFee(uint256 _fee) public onlyOwner {
makerFixedFee = _fee;
}
function updateFeeAddr(address _addr) public onlyOwner {
feeAddr = _addr;
}
function updateLiquidityAddr(address _addr) public onlyOwner {
liquidtyAddr = _addr;
}
function updateStakeAddr(address _addr) public onlyOwner {
stakeAddr = _addr;
}
function hastaked(address _who) internal returns(bool) {
if(stakeAddr==address(0)){
return true;
}
return IStaking(stakeAddr).hastaked(_who);
}
}
contract FixedPoolFactory is Events, AbstractFactory, Destructor {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct FixedPool {
string name;
address payable maker;
uint32 endTime;
bool enabled;
uint256 tokenRate;
address tokenaddr;
uint256 tokenAmount; // left amount
uint256 units;
bool onlyHolder;
}
mapping(uint32 => FixedPool) public fixedPools;
uint32 public fixedPoolCnt = 0;
function createFixedPool(string memory _name, address _tracker, uint256 _amount, uint256 _rate, uint256 _units, uint32 _endTime, bool _onlyHolder) makerFee onlyBeforeDestruct payable public {
require(_amount>0, "check create pool amount");
require(_rate>0, "check create pool rate");
require(_units>0, "check create pool units");
// transfer erc20 token from maker
IERC20(_tracker).safeTransferFrom(msg.sender, address(this), _amount);
fixedPools[fixedPoolCnt] = FixedPool({
maker : msg.sender,
tokenRate : _rate,
tokenaddr : _tracker,
tokenAmount : _amount,
name: _name,
endTime: uint32(now) + _endTime,
units: _units,
enabled: true,
onlyHolder: _onlyHolder
});
emit CreatePool(fixedPoolCnt, msg.sender, false, _tracker, _amount, _rate, _units);
fixedPoolCnt++;
}
function fixedPoolJoin(uint32 _id, uint256 _value) takerFee(_value) payable public {
require(msg.value > 0, "check value, value must be gt 0");
require(_value <= msg.value, "check value, value must be le msg.value");
FixedPool storage _pool = fixedPools[_id];
// check pool exist
require(_pool.enabled, "check pool exists");
if(_pool.onlyHolder){
require(hastaked(msg.sender), "only holder");
}
// check end time
require(now < _pool.endTime, "check before end time");
uint _order = _value.mul(_pool.tokenRate).div(_pool.units);
require(_order>0, "check taker amount");
require(_order<=_pool.tokenAmount, "check left token amount");
address _taker = msg.sender; // todo test gas
_pool.tokenAmount = _pool.tokenAmount.sub(_order);
// transfer ether to maker
_pool.maker.transfer(_value);
IERC20(_pool.tokenaddr).safeTransfer(_taker, _order);
emit Join(_id, msg.sender, false, _value, _pool.tokenaddr, _order);
joinPoolAfter(msg.sender, _value);
}
function fixedPoolClose(uint32 _id) public {
FixedPool storage _pool = fixedPools[_id];
require(_pool.enabled, "check pool exists");
require(_pool.maker == msg.sender, "check maker owner");
_pool.enabled = false;
IERC20(_pool.tokenaddr).safeTransfer(_pool.maker, _pool.tokenAmount);
emit Close(_id, false);
}
}
contract PrivFixedPoolFactory is Events, AbstractFactory, Destructor {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct PrivFixedPool {
string name;
address payable maker;
uint32 endTime;
bool enabled;
uint256 tokenRate;
address tokenaddr;
uint256 tokenAmount; // left amount
uint256 units;
address[] takers;
}
mapping(uint32 => PrivFixedPool) public privFixedPools;
uint32 public privFixedPoolCnt = 0;
function createPrivFixedPool(string memory _name, address _tracker, uint256 _amount, uint256 _rate, uint256 _units, uint32 _endTime, address[] memory _takers)
makerFee onlyBeforeDestruct payable public {
require(_amount>0, "check create pool amount");
require(_rate>0, "check create pool amount");
require(_units>0, "check create pool amount");
// transfer erc20 token from maker
IERC20(_tracker).safeTransferFrom(msg.sender, address(this), _amount);
privFixedPools[privFixedPoolCnt] = PrivFixedPool({
maker : msg.sender,
tokenRate : _rate,
tokenaddr : _tracker,
tokenAmount : _amount,
name: _name,
endTime: uint32(now) + _endTime,
units: _units,
enabled: true,
takers: _takers
});
emit CreatePool(privFixedPoolCnt, msg.sender, true, _tracker, _amount, _rate, _units);
privFixedPoolCnt++;
}
function privFixedPoolJoin(uint32 _id, uint32 _index, uint256 _value) takerFee(_value) payable public {
require(msg.value > 0, "check value, value must be gt 0");
require(_value <= msg.value, "check value, value must be le msg.value");
PrivFixedPool storage _pool = privFixedPools[_id];
// check pool exist
require(_pool.enabled, "check pool exists");
// check end time
require(now < _pool.endTime, "check before end time");
// check taker limit
require(_pool.takers[_index] == msg.sender, "check taker limit");
uint _order = msg.value.mul(_pool.tokenRate).div(_pool.units);
require(_order>0, "check taker amount");
require(_order<=_pool.tokenAmount, "check left token amount");
address _taker = msg.sender; // todo test gas
_pool.tokenAmount = _pool.tokenAmount.sub(_order);
// transfer ether to maker
_pool.maker.transfer(_value);
IERC20(_pool.tokenaddr).safeTransfer(_taker, _order);
emit Join(_id, msg.sender, true, msg.value, _pool.tokenaddr, _order);
joinPoolAfter(msg.sender, msg.value);
}
function privFixedPoolClose(uint32 _id) public {
PrivFixedPool storage _pool = privFixedPools[_id];
require(_pool.enabled, "check pool exists");
require(_pool.maker == msg.sender, "check maker owner");
_pool.enabled = false;
IERC20(_pool.tokenaddr).safeTransfer(_pool.maker, _pool.tokenAmount);
emit Close(_id, true);
}
function privFixedPoolTakers(uint32 _id) public view returns(address[] memory){
PrivFixedPool storage _pool = privFixedPools[_id];
return _pool.takers;
}
}
contract PoolFactory is FixedPoolFactory, PrivFixedPoolFactory {}
contract BidPoolFactory is Events, AbstractFactory, Destructor {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct BidPool {
string name;
address payable maker;
uint32 endTime;
bool enabled;
address tokenaddr;
uint256 tokenAmount; // maker erc20 token amount
uint256 takerAmountTotal; // taker ether coin amount
uint256 makerReceiveTotal; // maker received = all - fee
mapping(address=>uint256) takerAmountMap; // taker ether coin amount
bool onlyHolder; // only token holder could join
}
mapping(uint32 => BidPool) public bidPools;
uint32 public bidPoolCnt = 0;
function createBidPool(string memory _name, address _tracker, uint256 _amount, uint32 _endTime, bool _onlyHolder) makerFee onlyBeforeDestruct payable public {
require(_amount>0, "check create pool amount");
// transfer erc20 token from maker
IERC20(_tracker).safeTransferFrom(msg.sender, address(this), _amount);
bidPools[bidPoolCnt] = BidPool({
name: _name,
maker : msg.sender,
endTime: uint32(now) + _endTime,
tokenaddr : _tracker,
tokenAmount : _amount,
takerAmountTotal: 0,
enabled: true,
makerReceiveTotal:0,
onlyHolder:_onlyHolder
});
emit CreatePool(bidPoolCnt, msg.sender, false, _tracker, _amount, 0, 0);
bidPoolCnt++;
}
function bidPoolJoin(uint32 _id, uint256 _value) takerFee(_value) payable public {
require(msg.value > 0, "check value, value must be gt 0");
require(_value <= msg.value, "check value, value must be le msg.value");
BidPool storage _pool = bidPools[_id];
// check pool exist
require(_pool.enabled, "check pool exists");
// check end time
require(now < _pool.endTime, "check before end time");
// check holder
if(_pool.onlyHolder){
require(hastaked(msg.sender), "only holder");
}
address _taker = msg.sender;
_pool.takerAmountMap[_taker] = _pool.takerAmountMap[_taker].add(_value);
_pool.takerAmountTotal = _pool.takerAmountTotal.add(_value);
_pool.makerReceiveTotal = _pool.makerReceiveTotal.add(_value);
emit Join(_id, msg.sender, false, _value, _pool.tokenaddr, 0);
joinPoolAfter(msg.sender, _value);
}
function bidPoolTakerWithdraw(uint32 _id) public {
BidPool storage _pool = bidPools[_id];
// check end time
require(now > _pool.endTime, "check after end time");
address _taker = msg.sender;
uint256 _amount = _pool.takerAmountMap[_taker];
require(_amount>0, "amount check");
uint256 _order = _amount.mul(_pool.tokenAmount).div(_pool.takerAmountTotal);
// clear taker amount
delete _pool.takerAmountMap[_taker];
IERC20(_pool.tokenaddr).safeTransfer(_taker, _order);
emit Withdraw(_id, _taker, _order, uint32(2));
}
function bidPoolMakerWithdraw(uint32 _id) public {
BidPool storage _pool = bidPools[_id];
// check end time
require(now > _pool.endTime, "check after end time");
require(_pool.enabled, "check pool enabled");
require(_pool.maker == msg.sender, "check pool owner");
if( _pool.takerAmountTotal == 0 ){
_pool.enabled = false;
IERC20(_pool.tokenaddr).safeTransfer(_pool.maker, _pool.tokenAmount);
return;
}
uint256 _order = _pool.makerReceiveTotal;
require( _order>0, "check received value");
_pool.makerReceiveTotal = 0;
msg.sender.transfer(_order);
emit Withdraw(_id, msg.sender, _order, uint32(1));
}
function bidTakerAmount(uint32 _id, address _taker) public view returns(uint256) {
BidPool storage _pool = bidPools[_id];
uint256 _amount = _pool.takerAmountMap[_taker];
return _amount;
}
} | transfer erc20 token from maker | function createBidPool(string memory _name, address _tracker, uint256 _amount, uint32 _endTime, bool _onlyHolder) makerFee onlyBeforeDestruct payable public {
require(_amount>0, "check create pool amount");
IERC20(_tracker).safeTransferFrom(msg.sender, address(this), _amount);
bidPools[bidPoolCnt] = BidPool({
name: _name,
maker : msg.sender,
endTime: uint32(now) + _endTime,
tokenaddr : _tracker,
tokenAmount : _amount,
takerAmountTotal: 0,
enabled: true,
makerReceiveTotal:0,
onlyHolder:_onlyHolder
});
emit CreatePool(bidPoolCnt, msg.sender, false, _tracker, _amount, 0, 0);
bidPoolCnt++;
}
| 10,850,298 | [
1,
13866,
6445,
71,
3462,
1147,
628,
312,
6388,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
752,
17763,
2864,
12,
1080,
3778,
225,
389,
529,
16,
1758,
389,
16543,
16,
2254,
5034,
389,
8949,
16,
2254,
1578,
389,
409,
950,
16,
1426,
389,
3700,
6064,
13,
312,
6388,
14667,
1338,
4649,
6305,
8813,
8843,
429,
1071,
288,
203,
3639,
2583,
24899,
8949,
34,
20,
16,
315,
1893,
752,
2845,
3844,
8863,
203,
203,
3639,
467,
654,
39,
3462,
24899,
16543,
2934,
4626,
5912,
1265,
12,
3576,
18,
15330,
16,
1758,
12,
2211,
3631,
389,
8949,
1769,
203,
203,
3639,
9949,
16639,
63,
19773,
2864,
11750,
65,
273,
605,
350,
2864,
12590,
203,
5411,
508,
30,
389,
529,
16,
203,
5411,
312,
6388,
294,
1234,
18,
15330,
16,
203,
5411,
13859,
30,
2254,
1578,
12,
3338,
13,
397,
389,
409,
950,
16,
203,
5411,
1147,
4793,
294,
389,
16543,
16,
203,
5411,
1147,
6275,
294,
389,
8949,
16,
203,
5411,
268,
6388,
6275,
5269,
30,
374,
16,
203,
5411,
3696,
30,
638,
16,
203,
5411,
312,
6388,
11323,
5269,
30,
20,
16,
203,
5411,
1338,
6064,
30,
67,
3700,
6064,
203,
5411,
15549,
203,
3639,
3626,
1788,
2864,
12,
19773,
2864,
11750,
16,
1234,
18,
15330,
16,
629,
16,
389,
16543,
16,
389,
8949,
16,
374,
16,
374,
1769,
203,
3639,
9949,
2864,
11750,
9904,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity =0.8.10 >=0.8.10 >=0.8.0 <0.9.0;
pragma experimental ABIEncoderV2;
////// lib/openzeppelin-contracts/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.0 (utils/Context.sol)
/* 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) {
return msg.data;
}
}
////// lib/openzeppelin-contracts/contracts/access/Ownable.sol
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)
/* pragma solidity ^0.8.0; */
/* import "../utils/Context.sol"; */
/**
* @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.
*/
abstract 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() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(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");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
////// lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol
// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)
/* pragma solidity ^0.8.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);
}
////// lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol
// OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/IERC20Metadata.sol)
/* pragma solidity ^0.8.0; */
/* import "../IERC20.sol"; */
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
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);
}
////// lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol
// OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol)
/* pragma solidity ^0.8.0; */
/* import "./IERC20.sol"; */
/* import "./extensions/IERC20Metadata.sol"; */
/* import "../../utils/Context.sol"; */
/**
* @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 Contracts guidelines: functions revert
* instead 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 default 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
* overridden;
*
* 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");
unchecked {
_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");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This 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");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(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:
*
* - `account` 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);
_afterTokenTransfer(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");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(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 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 Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
////// lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol
// OpenZeppelin Contracts v4.4.0 (utils/math/SafeMath.sol)
/* pragma solidity ^0.8.0; */
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// 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 (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @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) {
return a + b;
}
/**
* @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 a - b;
}
/**
* @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) {
return a * b;
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting 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 a % b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
/**
* @dev Returns the integer division of two unsigned integers, reverting 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) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* 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) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
////// src/IUniswapV2Factory.sol
/* pragma solidity 0.8.10; */
/* pragma experimental ABIEncoderV2; */
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
////// src/IUniswapV2Pair.sol
/* pragma solidity 0.8.10; */
/* pragma experimental ABIEncoderV2; */
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
////// src/IUniswapV2Router02.sol
/* pragma solidity 0.8.10; */
/* pragma experimental ABIEncoderV2; */
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
/* pragma solidity >=0.8.10; */
/* import {IUniswapV2Router02} from "./IUniswapV2Router02.sol"; */
/* import {IUniswapV2Factory} from "./IUniswapV2Factory.sol"; */
/* import {IUniswapV2Pair} from "./IUniswapV2Pair.sol"; */
/* import {IERC20} from "lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; */
/* import {ERC20} from "lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol"; */
/* import {Ownable} from "lib/openzeppelin-contracts/contracts/access/Ownable.sol"; */
/* import {SafeMath} from "lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol"; */
contract soad is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public percentForLPBurn = 25; // 25 = .25%
bool public lpBurnEnabled = true;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("Soad", "SOAD") {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
);
excludeFromMaxTransaction(address(_uniswapV2Router), true);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
excludeFromMaxTransaction(address(uniswapV2Pair), true);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
uint256 _buyMarketingFee = 5;
uint256 _buyLiquidityFee = 0;
uint256 _buyDevFee = 0;
uint256 _sellMarketingFee = 5;
uint256 _sellLiquidityFee = 0;
uint256 _sellDevFee = 0;
uint256 totalSupply = 1_000_000_000 * 1e18;
maxTransactionAmount = 10_000_001 * 1e18; // 1% from total supply maxTransactionAmountTxn
maxWallet = 20_000_001 * 1e18; // 2% from total supply maxWallet
swapTokensAtAmount = (totalSupply * 5) / 10_000; // 0.05% swap wallet
buyMarketingFee = _buyMarketingFee;
buyLiquidityFee = _buyLiquidityFee;
buyDevFee = _buyDevFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
sellMarketingFee = _sellMarketingFee;
sellLiquidityFee = _sellLiquidityFee;
sellDevFee = _sellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
marketingWallet = address(0x08253bD854E7885cfd732032F6821d0AC742bC66); // set as marketing wallet
devWallet = address(0x08253bD854E7885cfd732032F6821d0AC742bC66); // set as dev wallet
// exclude from paying fees or having max transaction amount
excludeFromFees(owner(), true);
excludeFromFees(address(this), true);
excludeFromFees(address(0xdead), true);
excludeFromMaxTransaction(owner(), true);
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(address(0xdead), true);
/*
_mint is an internal function in ERC20.sol that is only called here,
and CANNOT be called ever again
*/
_mint(msg.sender, totalSupply);
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
tradingActive = true;
swapEnabled = true;
lastLpBurnTime = block.timestamp;
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
limitsInEffect = false;
return true;
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
transferDelayEnabled = false;
return true;
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
require(
newAmount >= (totalSupply() * 1) / 100000,
"Swap amount cannot be lower than 0.001% total supply."
);
require(
newAmount <= (totalSupply() * 5) / 1000,
"Swap amount cannot be higher than 0.5% total supply."
);
swapTokensAtAmount = newAmount;
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
require(
newNum >= ((totalSupply() * 1) / 10000) / 1e18,
"Cannot set maxTransactionAmount lower than 0.01%"
);
maxTransactionAmount = newNum * (10**18);
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(
newNum >= ((totalSupply() * 5) / 1000) / 1e18,
"Cannot set maxWallet lower than 0.5%"
);
maxWallet = newNum * (10**18);
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
_isExcludedMaxTransactionAmount[updAds] = isEx;
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
swapEnabled = enabled;
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
buyMarketingFee = _marketingFee;
buyLiquidityFee = _liquidityFee;
buyDevFee = _devFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
require(buyTotalFees <= 20, "Must keep fees at 20% or less");
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
sellMarketingFee = _marketingFee;
sellLiquidityFee = _liquidityFee;
sellDevFee = _devFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
require(sellTotalFees <= 25, "Must keep fees at 25% or less");
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
require(
pair != uniswapV2Pair,
"The pair cannot be removed from automatedMarketMakerPairs"
);
_setAutomatedMarketMakerPair(pair, value);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
emit marketingWalletUpdated(newMarketingWallet, marketingWallet);
marketingWallet = newMarketingWallet;
}
function updateDevWallet(address newWallet) external onlyOwner {
emit devWalletUpdated(newWallet, devWallet);
devWallet = newWallet;
}
function isExcludedFromFees(address account) public view returns (bool) {
return _isExcludedFromFees[account];
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (
to != owner() &&
to != address(uniswapV2Router) &&
to != address(uniswapV2Pair)
) {
require(
_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
if (
!swapping &&
automatedMarketMakerPairs[to] &&
lpBurnEnabled &&
block.timestamp >= lastLpBurnTime + lpBurnFrequency &&
!_isExcludedFromFees[from]
) {
autoBurnLiquidityPairTokens();
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForDev += (fees * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
// make the swap
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
// add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
deadAddress,
block.timestamp
);
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity +
tokensForMarketing +
tokensForDev;
bool success;
if (contractBalance == 0 || totalTokensToSwap == 0) {
return;
}
if (contractBalance > swapTokensAtAmount * 20) {
contractBalance = swapTokensAtAmount * 20;
}
// Halve the amount of liquidity tokens
uint256 liquidityTokens = (contractBalance * tokensForLiquidity) /
totalTokensToSwap /
2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(
totalTokensToSwap
);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
(success, ) = address(devWallet).call{value: ethForDev}("");
if (liquidityTokens > 0 && ethForLiquidity > 0) {
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(
amountToSwapForETH,
ethForLiquidity,
tokensForLiquidity
);
}
(success, ) = address(marketingWallet).call{
value: address(this).balance
}("");
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
require(
_frequencyInSeconds >= 600,
"cannot set buyback more often than every 10 minutes"
);
require(
_percent <= 1000 && _percent >= 0,
"Must set auto LP burn percent between 0% and 10%"
);
lpBurnFrequency = _frequencyInSeconds;
percentForLPBurn = _percent;
lpBurnEnabled = _Enabled;
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
lastLpBurnTime = block.timestamp;
// get balance of liquidity pair
uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);
// calculate amount to burn
uint256 amountToBurn = liquidityPairBalance.mul(percentForLPBurn).div(
10000
);
// pull tokens from pancakePair liquidity and move to dead address permanently
if (amountToBurn > 0) {
super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);
}
//sync price since this is not in a swap transaction!
IUniswapV2Pair pair = IUniswapV2Pair(uniswapV2Pair);
pair.sync();
emit AutoNukeLP();
return true;
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
require(
block.timestamp > lastManualLpBurnTime + manualBurnFrequency,
"Must wait for cooldown to finish"
);
require(percent <= 1000, "May not nuke more than 10% of tokens in LP");
lastManualLpBurnTime = block.timestamp;
// get balance of liquidity pair
uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);
// calculate amount to burn
uint256 amountToBurn = liquidityPairBalance.mul(percent).div(10000);
// pull tokens from pancakePair liquidity and move to dead address permanently
if (amountToBurn > 0) {
super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);
}
//sync price since this is not in a swap transaction!
IUniswapV2Pair pair = IUniswapV2Pair(uniswapV2Pair);
pair.sync();
emit ManualNukeLP();
return true;
}
} | set as marketing wallet
| marketingWallet = address(0x08253bD854E7885cfd732032F6821d0AC742bC66); | 10,104,727 | [
1,
542,
487,
13667,
310,
9230,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
13667,
310,
16936,
273,
1758,
12,
20,
92,
6840,
30304,
70,
40,
28,
6564,
41,
27,
5482,
25,
71,
8313,
27,
31273,
1578,
42,
9470,
5340,
72,
20,
2226,
5608,
22,
70,
39,
6028,
1769,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import { IJustCausePool } from './Interfaces.sol';
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721URIStorageUpgradeable.sol";
/**
* @title JCDepositorERC721
* @author JustCause
* This is a proof of concept starter contract for lossless donations
*
* Aave v3 is used to generate interest for crowdfunding
*
* Creates an ERC721 with info regarding each Just Cause Pool depositor
*
* Inherets from openzeppelin ERC721 contracts
*
**/
contract JCDepositorERC721 is ERC721URIStorageUpgradeable {
struct Deposit {
uint256 balance;
uint256 timeStamp;
address asset;
}
address jcPool;
address poolTracker;
//key = keccak hash of depositor, pool and asset addresses
mapping (uint256 => Deposit) deposits;
/**
* @dev Only Master can call functions marked by this modifier.
**/
modifier onlyPoolTracker(){
require(poolTracker == msg.sender, "not the owner");
_;
}
function initialize(address _jcPool) initializer public {
__ERC721_init("JCP Contributor Token", "JCPC");
jcPool = _jcPool;
poolTracker = msg.sender;
}
/**
* @dev Creates NFT for depositor if first deposit for pool and asset
* @param _tokenOwner address of depositor
* @param _timeStamp timeStamp of token creation
* @param _metaUri meta info uri for nft of JCP
* @param _asset The address of the underlying asset of the reserve
* @return tokenId unique tokenId keccak hash of depositor, pool and asset addresses
**/
function addFunds(
address _tokenOwner,
uint256 _amount,
uint256 _timeStamp,
address _asset,
string memory _metaUri
) public onlyPoolTracker returns (bool) {
//tokenId is keccak hash of depositor, pool and asset addresses
uint256 tokenId = uint256(keccak256(abi.encodePacked(_tokenOwner, jcPool, _asset)));
bool firstDeposit = false;
if(_exists(tokenId)){
deposits[tokenId].timeStamp = _timeStamp;
deposits[tokenId].balance += _amount;
}
else{
deposits[tokenId] = Deposit(_amount, _timeStamp, _asset);
_mint(_tokenOwner, tokenId);
_setTokenURI(tokenId, _metaUri);
firstDeposit = true;
}
return firstDeposit;
}
/**
* @dev Withdraw balance for depositor
* @param _tokenOwner address of depositor
* @param _amount amount to withdraw
* @param _asset The address of the underlying asset of the reserve
**/
function withdrawFunds(address _tokenOwner, uint256 _amount, address _asset) onlyPoolTracker external{
uint256 tokenId = uint256(keccak256(abi.encodePacked(_tokenOwner, jcPool, _asset)));
require(_exists(tokenId), "tokenId doesn't exist");
uint256 balance = deposits[tokenId].balance;
require(balance >= _amount, "insufficient balance");
balance -= _amount;
if(balance == 0){
deposits[tokenId].timeStamp = 0;
}
deposits[tokenId].balance = balance;
}
/**
* @param _tokenId unique tokenId keccak hash of depositor, pool and asset addresses
* @return Deposit struct containing info about deposit
**/
function getDepositInfo(uint256 _tokenId) public view returns (Deposit memory){
return deposits[_tokenId];
}
/**
* @param _tokenId unique tokenId keccak hash of depositor, pool and asset addresses
* @return asset balance of user in pool
**/
function getUserBalance(uint256 _tokenId) public view returns (uint256){
return deposits[_tokenId].balance;
}
function getUserTokens(address _tokenOwner) external view returns(uint256[] memory){
address[] memory assets = IJustCausePool(jcPool).getAcceptedTokens();
uint256 len = assets.length;
uint256[] memory ids = new uint256[](len);
for(uint256 i = 0; i < len; i++){
uint256 tokenId = uint256(keccak256(abi.encodePacked(_tokenOwner, jcPool, assets[i])));
if(_exists(tokenId)){
ids[i] = tokenId;
//counter = counter + 1;
}
}
return ids;
}
function getPool() public view returns(address){
return jcPool;
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721Upgradeable)
{
require(from == address(0), "non-transferrable");
super._beforeTokenTransfer(from, to, tokenId);
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721URIStorageUpgradeable)
returns (string memory)
{
return super.tokenURI(tokenId);
}
} | counter = counter + 1; | function getUserTokens(address _tokenOwner) external view returns(uint256[] memory){
address[] memory assets = IJustCausePool(jcPool).getAcceptedTokens();
uint256 len = assets.length;
uint256[] memory ids = new uint256[](len);
for(uint256 i = 0; i < len; i++){
uint256 tokenId = uint256(keccak256(abi.encodePacked(_tokenOwner, jcPool, assets[i])));
if(_exists(tokenId)){
ids[i] = tokenId;
}
}
return ids;
}
| 1,758,683 | [
1,
7476,
273,
3895,
397,
404,
31,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
4735,
5157,
12,
2867,
389,
2316,
5541,
13,
3903,
1476,
1135,
12,
11890,
5034,
8526,
3778,
15329,
203,
3639,
1758,
8526,
3778,
7176,
273,
467,
19642,
10683,
2864,
12,
78,
71,
2864,
2934,
588,
18047,
5157,
5621,
203,
3639,
2254,
5034,
562,
273,
7176,
18,
2469,
31,
203,
3639,
2254,
5034,
8526,
3778,
3258,
273,
394,
2254,
5034,
8526,
12,
1897,
1769,
203,
3639,
364,
12,
11890,
5034,
277,
273,
374,
31,
277,
411,
562,
31,
277,
27245,
95,
203,
5411,
2254,
5034,
1147,
548,
273,
2254,
5034,
12,
79,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
24899,
2316,
5541,
16,
19807,
2864,
16,
7176,
63,
77,
22643,
1769,
203,
5411,
309,
24899,
1808,
12,
2316,
548,
3719,
95,
203,
7734,
3258,
63,
77,
65,
273,
1147,
548,
31,
203,
5411,
289,
203,
3639,
289,
203,
3639,
327,
3258,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/3/0xf4f48955F2e3Dff09e15Dde15144d8e2BEa05A19/sources/Maker.sol | makerOrders[id] = order; | function cancelAddLiquidity(
address sender,
uint id
) external _onlyRouter returns (uint _amount){
Types.MakerOrder storage order = makerOrders[id];
require(order.id != 0, 'not exist');
require(order.maker == sender, 'Caller is not order owner');
require(order.action == Types.PoolAction.Deposit, 'not deposit');
require(order.status == Types.PoolActionStatus.Submit, 'not submit');
require(block.number > order.submitBlockHeight.add(IManager(manager).cancelBlockElapse()), 'Can not cancel');
IUser(userAddress).receiveToken(clearAnchorAddress, order.maker, order.amount);
TransferHelper.safeTransfer(clearAnchorAddress, userAddress, order.amount);
order.status = Types.PoolActionStatus.Cancel;
_amount = order.amount;
}
| 5,065,594 | [
1,
29261,
16528,
63,
350,
65,
273,
1353,
31,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
3755,
986,
48,
18988,
24237,
12,
203,
3639,
1758,
5793,
16,
203,
3639,
2254,
612,
203,
565,
262,
3903,
389,
3700,
8259,
1135,
261,
11890,
389,
8949,
15329,
203,
3639,
7658,
18,
12373,
2448,
2502,
1353,
273,
312,
6388,
16528,
63,
350,
15533,
203,
3639,
2583,
12,
1019,
18,
350,
480,
374,
16,
296,
902,
1005,
8284,
203,
3639,
2583,
12,
1019,
18,
29261,
422,
5793,
16,
296,
11095,
353,
486,
1353,
3410,
8284,
203,
3639,
2583,
12,
1019,
18,
1128,
422,
7658,
18,
2864,
1803,
18,
758,
1724,
16,
296,
902,
443,
1724,
8284,
203,
3639,
2583,
12,
1019,
18,
2327,
422,
7658,
18,
2864,
1803,
1482,
18,
11620,
16,
296,
902,
4879,
8284,
203,
3639,
2583,
12,
2629,
18,
2696,
405,
1353,
18,
9297,
1768,
2686,
18,
1289,
12,
45,
1318,
12,
4181,
2934,
10996,
1768,
41,
14820,
1435,
3631,
296,
2568,
486,
3755,
8284,
203,
3639,
467,
1299,
12,
1355,
1887,
2934,
18149,
1345,
12,
8507,
11605,
1887,
16,
1353,
18,
29261,
16,
1353,
18,
8949,
1769,
203,
3639,
12279,
2276,
18,
4626,
5912,
12,
8507,
11605,
1887,
16,
729,
1887,
16,
1353,
18,
8949,
1769,
203,
3639,
1353,
18,
2327,
273,
7658,
18,
2864,
1803,
1482,
18,
6691,
31,
203,
3639,
389,
8949,
273,
1353,
18,
8949,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/1/0x1bAC1E3003668fc0Cc4838DD3Fb62E8C2671b271/sources/browser/TorroDao.sol | @notice Execution of SET_MIN_VOTES proposal. @param proposal_ proposal. | function _executeSetMinVotes(Proposal storage proposal_) private {
_minProposalVotes = proposal_.amount;
}
| 3,118,742 | [
1,
3210,
434,
7855,
67,
6236,
67,
16169,
7296,
14708,
18,
225,
14708,
67,
14708,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
225,
445,
389,
8837,
694,
2930,
29637,
12,
14592,
2502,
14708,
67,
13,
3238,
288,
203,
565,
389,
1154,
14592,
29637,
273,
14708,
27799,
8949,
31,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/100/0x87926e4dCB09bE44B54b9863322c43DfdA98b687/sources/contracts/LSP0ERC725Account/ILSP0ERC725Account.sol | * @title The Interface of LSP0-ERC725Account Standard @author Fabian Vogelsteller <[email protected]>, Jean Cavallera (CJ42) @dev A smart contract account including basic functionalities such as: - Detecting supported standards using ERC165 - Executing several operation on other addresses including creating contracts using ERC725X - Storing data in a generic way using ERC725Y - Validating signatures using ERC1271 - Receiving notification and react on them using LSP1 - Secure ownership management using LSP14 - Extending the account with new functions and interfaceIds of future standards using LSP17 - Verifying calls on the owner to allow unified and standard interaction with the account using LSP20 This interface implicitly inherits: IERC165, IERC725X, IERC725Y, IERC1271, ILSP1UniversalReceiver, ILSP14Ownable2Step/ | interface ILSP0ERC725Account {
event ValueReceived(address indexed sender, uint256 indexed value);
function batchCalls(bytes[] calldata data) external returns (bytes[] memory results);
pragma solidity ^0.8.4;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {IERC725X} from "@erc725/smart-contracts/contracts/interfaces/IERC725X.sol";
import {IERC725Y} from "@erc725/smart-contracts/contracts/interfaces/IERC725Y.sol";
import {IERC1271} from "@openzeppelin/contracts/interfaces/IERC1271.sol";
import {ILSP1UniversalReceiver} from "../LSP1UniversalReceiver/ILSP1UniversalReceiver.sol";
import {ILSP14Ownable2Step} from "../LSP14Ownable2Step/ILSP14Ownable2Step.sol";
}
| 14,284,921 | [
1,
1986,
6682,
434,
511,
3118,
20,
17,
654,
39,
27,
2947,
3032,
8263,
225,
478,
378,
2779,
776,
717,
292,
334,
292,
749,
411,
74,
378,
2779,
36,
80,
19445,
2048,
18,
5185,
20401,
804,
73,
304,
385,
842,
454,
6070,
261,
39,
46,
9452,
13,
225,
432,
13706,
6835,
2236,
6508,
5337,
18699,
1961,
4123,
487,
30,
300,
13796,
310,
3260,
4529,
87,
1450,
4232,
39,
28275,
300,
3889,
8490,
11392,
1674,
603,
1308,
6138,
6508,
4979,
20092,
1450,
4232,
39,
27,
2947,
60,
300,
934,
6053,
501,
316,
279,
5210,
4031,
1450,
4232,
39,
27,
2947,
61,
300,
2364,
1776,
14862,
1450,
4232,
39,
2138,
11212,
300,
9797,
9288,
3851,
471,
13417,
603,
2182,
1450,
511,
3118,
21,
300,
15653,
23178,
11803,
1450,
511,
3118,
3461,
300,
6419,
2846,
326,
2236,
598,
394,
4186,
471,
1560,
2673,
434,
3563,
4529,
87,
1450,
511,
3118,
4033,
300,
2
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
] | [
1,
5831,
467,
3045,
52,
20,
654,
39,
27,
2947,
3032,
288,
203,
565,
871,
1445,
8872,
12,
2867,
8808,
5793,
16,
2254,
5034,
8808,
460,
1769,
203,
203,
565,
445,
2581,
10125,
12,
3890,
8526,
745,
892,
501,
13,
3903,
1135,
261,
3890,
8526,
3778,
1686,
1769,
203,
683,
9454,
18035,
560,
3602,
20,
18,
28,
18,
24,
31,
203,
5666,
288,
45,
654,
39,
28275,
97,
628,
8787,
3190,
94,
881,
84,
292,
267,
19,
16351,
87,
19,
5471,
19,
474,
26362,
19,
45,
654,
39,
28275,
18,
18281,
14432,
203,
5666,
288,
45,
654,
39,
27,
2947,
60,
97,
628,
8787,
12610,
27,
2947,
19,
26416,
17,
16351,
87,
19,
16351,
87,
19,
15898,
19,
45,
654,
39,
27,
2947,
60,
18,
18281,
14432,
203,
5666,
288,
45,
654,
39,
27,
2947,
61,
97,
628,
8787,
12610,
27,
2947,
19,
26416,
17,
16351,
87,
19,
16351,
87,
19,
15898,
19,
45,
654,
39,
27,
2947,
61,
18,
18281,
14432,
203,
5666,
288,
45,
654,
39,
2138,
11212,
97,
628,
8787,
3190,
94,
881,
84,
292,
267,
19,
16351,
87,
19,
15898,
19,
45,
654,
39,
2138,
11212,
18,
18281,
14432,
203,
5666,
288,
2627,
3118,
21,
984,
14651,
12952,
97,
628,
315,
6216,
3045,
52,
21,
984,
14651,
12952,
19,
2627,
3118,
21,
984,
14651,
12952,
18,
18281,
14432,
203,
5666,
288,
2627,
3118,
3461,
5460,
429,
22,
4160,
97,
628,
315,
6216,
3045,
52,
3461,
5460,
429,
22,
4160,
19,
2627,
3118,
3461,
5460,
429,
22,
4160,
18,
18281,
14432,
203,
2
] |
pragma solidity >=0.4.22 <0.6.0;
contract ReduceCo2Ballot {
//proposal 1 2.5 and fair
//proposal 2 2.5 and not fair
//proposal 3 4.5 and fair
//proposal 4 4.5 and not fair
//proposal 5 6 and fair
//proposal 6 6 and not fair
//proposal 7 8.5 and fair
//proposal 8 8.5 and notfair
struct Voter {
uint weight;
bool voted;
uint8 vote;
address delegate;
uint Annual_income; //**// //what is the annual_income of the vote? we know their social class by this.
uint numsOfCarsOwned; //**// //how many cars does the vote owned?
bool climateChangeOrNot; //does the vote believe on climate change?
bool recievedClimateChangeEducation; // does the voter ever recieved some education about the climate change?
bool doYouTravelOften ; //does the voter travel place to place oftenly?
bool isMilitary; //does the vote serve in the Military ?
bool isSurvey; //does this person already fill out the Survey?
uint finalVoteWeight; //**//
uint age;
}
struct Proposal {
uint voteCount;
bool president_appoval;
uint winnerProposal;
}
address chairperson;
mapping(address => Voter) voters; // czx* this is hashtable
mapping(address => Proposal)proposal; // ni jia delegate
Proposal[] proposals;
uint8 temp;
/// Create a new ballot with $(_numProposals) different proposals.
constructor(uint8 _numProposals) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
proposals.length = _numProposals;
}
modifier requireBackGround()
{ Voter storage sender = voters[msg.sender]; //require voter must to fill out the background Survey before they can do
// anything else
require(sender.isSurvey == true);
_;
}
modifier require_Knownlege_of_CC ()
{ Voter storage sender = voters[msg.sender]; //require voter must already recieved climate change education
require(sender.recievedClimateChangeEducation == true);
_;
}
modifier isEighteen ()
{ Voter storage sender = voters[msg.sender]; //require voter must be eighteen or above to vote
require(sender.age >= 18);
_;
}
modifier onlychair()
{require(msg.sender == chairperson);
_;
}
modifier presidentAppoval ()
{ Proposal storage p = proposal[chairperson];
require(p.president_appoval == true);
_;
}
function vetoRight(bool president_appoval) onlychair public { // the chairman (U.S president) have right to veto the final vote result.
//
Proposal storage sender = proposal[chairperson];
Voter storage voter = voters[msg.sender];
sender.president_appoval = president_appoval;
if(president_appoval == true) {
sender.president_appoval = president_appoval;
return;
}
else {
sender.president_appoval = false;
sender.voteCount = 0;
return;
}
}
//president will look at the result to see if veto or not
function MostVotedProposal() view public returns(uint mostVotedProposal){
mostVotedProposal = temp;
return mostVotedProposal;
}
function carbonTaxOnProduct()presidentAppoval public view returns(uint lowerIncomeClass____TaxPercentage, uint middleIncomeClass___TaxPercentage,
uint midUpperIncomeClassTaxPercentage, uint UpperIncomeClass___TaxPercentage) {
uint FinalVoteResult = temp;
if(FinalVoteResult == 1){
lowerIncomeClass____TaxPercentage = 25;
middleIncomeClass___TaxPercentage = 25;
midUpperIncomeClassTaxPercentage = 25;
UpperIncomeClass___TaxPercentage = 25;
return(lowerIncomeClass____TaxPercentage,middleIncomeClass___TaxPercentage,midUpperIncomeClassTaxPercentage,UpperIncomeClass___TaxPercentage);
}
else if(FinalVoteResult == 2){
lowerIncomeClass____TaxPercentage = 5;
middleIncomeClass___TaxPercentage = 15;
midUpperIncomeClassTaxPercentage = 35;
UpperIncomeClass___TaxPercentage = 45;
return(lowerIncomeClass____TaxPercentage,middleIncomeClass___TaxPercentage,midUpperIncomeClassTaxPercentage,UpperIncomeClass___TaxPercentage);
}
else if(FinalVoteResult == 3){
lowerIncomeClass____TaxPercentage = 19;
middleIncomeClass___TaxPercentage = 19;
midUpperIncomeClassTaxPercentage = 19;
UpperIncomeClass___TaxPercentage = 19;
return(lowerIncomeClass____TaxPercentage,middleIncomeClass___TaxPercentage,midUpperIncomeClassTaxPercentage,UpperIncomeClass___TaxPercentage);
}
else if(FinalVoteResult == 4){
lowerIncomeClass____TaxPercentage = 5;
middleIncomeClass___TaxPercentage = 15;
midUpperIncomeClassTaxPercentage = 25;
UpperIncomeClass___TaxPercentage = 30;
return(lowerIncomeClass____TaxPercentage,middleIncomeClass___TaxPercentage,midUpperIncomeClassTaxPercentage,UpperIncomeClass___TaxPercentage);
}
else if(FinalVoteResult == 5){
lowerIncomeClass____TaxPercentage = 13;
middleIncomeClass___TaxPercentage = 13;
midUpperIncomeClassTaxPercentage = 13;
UpperIncomeClass___TaxPercentage = 13;
return(lowerIncomeClass____TaxPercentage,middleIncomeClass___TaxPercentage,midUpperIncomeClassTaxPercentage,UpperIncomeClass___TaxPercentage);
}
else if(FinalVoteResult == 6){
lowerIncomeClass____TaxPercentage = 5;
middleIncomeClass___TaxPercentage = 10;
midUpperIncomeClassTaxPercentage = 15;
UpperIncomeClass___TaxPercentage = 20;
return(lowerIncomeClass____TaxPercentage,middleIncomeClass___TaxPercentage,midUpperIncomeClassTaxPercentage,UpperIncomeClass___TaxPercentage);
}
else if(FinalVoteResult == 7){
lowerIncomeClass____TaxPercentage = 7;
middleIncomeClass___TaxPercentage = 7;
midUpperIncomeClassTaxPercentage = 7;
UpperIncomeClass___TaxPercentage = 7;
return(lowerIncomeClass____TaxPercentage,middleIncomeClass___TaxPercentage,midUpperIncomeClassTaxPercentage,UpperIncomeClass___TaxPercentage);
}
else if(FinalVoteResult == 8){
lowerIncomeClass____TaxPercentage = 3;
middleIncomeClass___TaxPercentage = 5;
midUpperIncomeClassTaxPercentage = 7;
UpperIncomeClass___TaxPercentage = 10;
return(lowerIncomeClass____TaxPercentage,middleIncomeClass___TaxPercentage,midUpperIncomeClassTaxPercentage,UpperIncomeClass___TaxPercentage);
}
}
function VoterBackground (uint numsofCar, uint annual_income, bool isclimateChange,bool recievedClimateChangeEducation,
bool doYouTravelOften, bool isMilitary, uint age) public {
Voter storage sender = voters[msg.sender];
sender.numsOfCarsOwned = numsofCar;
sender.Annual_income = annual_income;
sender.climateChangeOrNot = isclimateChange;
sender.recievedClimateChangeEducation = recievedClimateChangeEducation;
sender.doYouTravelOften = doYouTravelOften;
sender.isMilitary = isMilitary;
sender.isSurvey = true; // already fill out the background Survey;
sender.age = age;
}
function getBackGround()requireBackGround view public returns(uint numsofCar,uint annualIncome,bool isClimateChangeBeliver,
bool recievedClimateChangeEducation, bool doesVoterTravelOften, bool isMilitary, uint VoterAge) {
Voter storage sender = voters[msg.sender];
numsofCar = sender.numsOfCarsOwned;
annualIncome = sender.Annual_income;
isClimateChangeBeliver = sender.climateChangeOrNot;
recievedClimateChangeEducation = sender.recievedClimateChangeEducation;
doesVoterTravelOften = sender.doYouTravelOften;
isMilitary = sender.isMilitary;
VoterAge = sender.age;
return(numsofCar, annualIncome, isClimateChangeBeliver, recievedClimateChangeEducation, doesVoterTravelOften, isMilitary, VoterAge);
}
function VoteWeight () requireBackGround public{
Voter storage sender = voters[msg.sender];
uint carWeight = 0;
uint annual_income_weight = 0;
uint cc_Beliver_orNot_weight = 0;
uint travel_often_Weight = 0;
uint isMilitary_Weight = 0;
if(sender.age < 18 || sender.recievedClimateChangeEducation==false ) return;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if(sender.numsOfCarsOwned > 2) carWeight = 0;
else carWeight = 1;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if(sender.Annual_income < 30000) annual_income_weight = 3; //lower class
else if(sender.Annual_income > 30000 && sender.Annual_income < 90000) annual_income_weight=2; // middle class
else if(sender.Annual_income > 90000 && sender.Annual_income<130000) annual_income_weight = 1; //mid-upper class
else annual_income_weight = 0; // real upper class
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if(sender.climateChangeOrNot == true) cc_Beliver_orNot_weight = 2;
else cc_Beliver_orNot_weight = 1;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if(sender.doYouTravelOften == true) travel_often_Weight = 2;
else travel_often_Weight =1;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if(sender.isMilitary == true) isMilitary_Weight = 1;
else isMilitary_Weight = 0;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
uint temp = (carWeight + annual_income_weight + isMilitary_Weight - travel_often_Weight) * cc_Beliver_orNot_weight;
if(temp<=0){ // if after voteWeight and the weight of vote is less or equal to zero.
return;
}
else sender.finalVoteWeight = temp;
}
function getVoteWeight() requireBackGround require_Knownlege_of_CC isEighteen view public returns(uint){
Voter storage sender = voters[msg.sender];
return sender.finalVoteWeight;
}
/// Give $(toVoter) the right to vote on this ballot.
/// May only be called by $(chairperson).
function giveRightToVote(address toVoter) public {
if (msg.sender != chairperson || voters[toVoter].voted) return;
voters[toVoter].weight = 1;
}
/// Delegate your vote to the voter $(to).
function delegate(address to) public {
Voter storage sender = voters[msg.sender]; // assigns reference
if (sender.voted) return;
while (voters[to].delegate != address(0) && voters[to].delegate != msg.sender)
to = voters[to].delegate;
if (to == msg.sender) return;
sender.voted = true;
sender.delegate = to;
Voter storage delegateTo = voters[to];
if (delegateTo.voted)
proposals[delegateTo.vote].voteCount += sender.weight;
else
delegateTo.weight += sender.weight;
}
/// Give a single vote to proposal $(toProposal).
function vote(uint8 toProposal) requireBackGround isEighteen require_Knownlege_of_CC public {
if(toProposal>8 || toProposal == 0 ) return; //must be 1 of proposals out of 8
Voter storage sender = voters[msg.sender];
if (sender.voted || toProposal >= proposals.length) return;
sender.voted = true;
sender.vote = toProposal;
proposals[toProposal].voteCount += sender.finalVoteWeight;
Proposal storage p = proposal[chairperson];
p.president_appoval = true;
temp = winningProposal();
p.president_appoval = false;
}
function winningProposal()presidentAppoval public view returns (uint8 _winningProposal) {
uint256 winningVoteCount = 0;
for (uint8 prop = 0; prop < proposals.length; prop++){
if (proposals[prop].voteCount > winningVoteCount) {
winningVoteCount = proposals[prop].voteCount;
_winningProposal = prop;
}
}
}
}
| what is the annual_income of the vote? we know their social class by this.
| uint Annual_income; | 980,569 | [
1,
23770,
353,
326,
8226,
1462,
67,
267,
5624,
434,
326,
12501,
35,
732,
5055,
3675,
16702,
667,
635,
333,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
377,
2254,
225,
24936,
1462,
67,
267,
5624,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/1/0x6a6bc8ce19901f0e3e93ba6FAbCfD0a8a8bF180a/sources/browser/Augustus.sol | * @dev Modifier to make a function callable only when the contract is paused./ | modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
constructor(
address whitelist,
address gasToken,
address partnerRegistry,
address payable feeWallet,
address gstHolder
)
public
| 3,019,343 | [
1,
9829,
358,
1221,
279,
445,
4140,
1338,
1347,
326,
6835,
353,
17781,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
9606,
1347,
28590,
1435,
288,
203,
3639,
2583,
24899,
8774,
3668,
16,
315,
16507,
16665,
30,
486,
17781,
8863,
203,
3639,
389,
31,
203,
565,
289,
203,
203,
565,
3885,
12,
203,
3639,
1758,
10734,
16,
203,
3639,
1758,
16189,
1345,
16,
203,
3639,
1758,
19170,
4243,
16,
203,
3639,
1758,
8843,
429,
14036,
16936,
16,
203,
3639,
1758,
314,
334,
6064,
203,
565,
262,
203,
3639,
1071,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/1/0x84027C78ef73D1F9d5F9a902DAe02767847a52f5/sources/CBOT.sol | remove limits after token is stable | function removeLimits() external onlyAdmin returns (bool) {
limitsInEffect = false;
return true;
}
| 4,299,824 | [
1,
4479,
8181,
1839,
1147,
353,
14114,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
1206,
12768,
1435,
3903,
1338,
4446,
1135,
261,
6430,
13,
288,
203,
3639,
8181,
382,
12477,
273,
629,
31,
203,
3639,
327,
638,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------------------------::::////++++/----------
// ----------------------------------------------------------------------------------------------------------------------------/++++++++++++++/----------
// -----------------------------------:+++----------------------------------------------------------------------------------:++o++//:::------------------
// ------------------------------------+++/----------------------------------------------------------------------------------+++:------------------------
// -------------------------------------+++/---------------------------------------------------------------------------------+++:------------------------
// -------------------------------------:+++:--------------------------------------------------------------------------------+++:------------------------
// --------------------------------------:+++--------------------------------------------------------------------------------+++:------------------------
// ---------------------------------------+++/-------------------------------------------------------------------------------+++:------------------------
// ---------------------------------------/+++-------------------------------------------------------------------------------+++:------------------------
// ----------------------------------------+++:------------------------------------------------------/++/--------------------+++:------------------------
// ----------------------------------------+++/------------------------------------------------------/+++--------------------+++:------------------------
// ----------------------------------------/++/-------------------------------------------------------+++:-------------------+++:------------------------
// ----------------------------------------/+++-------------------------------------------------------+++/-------------------+++:------------------------
// ----------------------------------------/+++-------------------------------------------------------/++/-------------------+++:------------------------
// ----------------------------------------/+++--:::::--------------------------///---///:------------/+++------/+/:---------+++:------------------------
// ----------------------------------------/+++++++++++/-----------:::---------:+++---+oo+++++/:------:+++---/+oooo/---------+++:------------------------
// ----------------------------------------/+oo++/::/++++:---------+++:--------:+++---/ooo+//+++/-----:+++-/+oooo+:----------+++:------------------------
// -----------------------://++++///:------/ooo+------/+++:--------+++/--------:+++---/ooo:--:+++/----:++o+oooo+/------------+++:------------------------
// --------------------:++++++++++++++/:---:ooo+-------/+++:-------/++/--------:+++---/ooo:---:+++----:oosoo++:--------------+++:------------------------
// ------------------:++++/:-------:/+++++::ooo+--------/+++-------/++/--------:+++---:ooo-----+++/---/ooso/-----------------+++:------------------------
// -----------------/+++/-------------:/++++oooo:--------++++------/++/--------:+++---/ooo-----/+++---:ooso++::--------------+++:------------------------
// ----------------/+++:-----------------+++oooo/---------+++:-----/++/--------:+++---+ooo-----:+++---:ooo++++++/::----------+++:------------------------
// ---------------:+++:------------------+++oooo+---------/+++-----/+++--------:+++---oooo------+++:---ooo/-://++++++/-------+++:------------------------
// ---------------+++/------------------/+++/ooo+---------:+++------+++:------:+++/---oooo------+++:---ooo+-----::/++/-------++o/::::::::----------------
// --------------:+++-----------------:++++:-oooo----------+++:-----/+++/::::/+++/----+ooo------+++:---oooo------------------++oo++++++++----------------
// --------------:+++--------------:/++++/---oooo----------+++:------/+++++++++/:-----+ooo------+++:---+ooo:-----------------++o/:://///:----------------
// --------------:+oo//://///////++++++:-----+ooo----------/++/---------::::::--------/ooo------+++:---/ooo:-----------------+++:------------------------
// ---------------ooo+++++++++++++//:--------/ooo----------/++/-----------------------/ooo------/++/---:ooo/-----------------+++:------------------------
// ---------------+++:::::::::::-------------:://----------::::-----------------------:o++------/+++----ooo+-----------------+++:------------------------
// ---------------+++:--------------------------------------------------------------------------:+++----/+++-----------------+++:------------------------
// ---------------+++:---------------------------------------------------------------------------+++/------------------------+++:------------------------
// ---------------+++/---------------------------------------------------------------------------/+++------------------------+++:------------------------
// ---------------/++/----------------------------------------------------------------------------+++:-----------------------+++/------------------------
// ---------------/+++----------------------------------------------------------------------------/+++-----------------------+++/------------------------
// ---------------/+++-----------------------------------------------------------------------------:+:-----------------------+++/------------------------
// ---------------:+++-------------------------------------------------------------------------------------------------------/+++///////++++++++/--------
// ----------------+++:------------------------------------------------------------------------------------------------------:++++++++++++++++///--------
// ----------------+++/---------------------------------------------------------------------------------------------------------:------------------------
// ----------------/+++----------------------------------------------------------------------------------------------------------------------------------
// ----------------:+++----------------------------------------------------------------------------------------------------------------------------------
// -----------------+++:---------------------------------------------------------------------------------------------------------------------------------
// -----------------+++:---------------------------------------------------------------------------------------------------------------------------------
// -----------------+++/---------------------------------------------------------------------------------------------------------------------------------
// -----------------/++/---------------------------------------------------------------------------------------------------------------------------------
// -----------------/+++---------------------------------------------------------------------------------------------------------------------------------
// -----------------:+++---------------------------------------------------------------------------------------------------------------------------------
// ------------------+++:--------------------------------------------------------------------------------------------------------------------------------
// ------------------/++/--------------------------------------------------------------------------------------------------------------------------------
// ------------------/+++--------------------------------------------------------------------------------------------------------------------------------
// ------------------:+++--------------------------------------------------------------------------------------------------------------------------------
// -------------------+++:-------------------------------------------------------------------------------------------------------------------------------
// -------------------+++:-------------------------------------------------------------------------------------------------------------------------------
// -------------------+++/-------------------------------------------------------------------------------------------------------------------------------
// -------------------/++/-------------------------------------------------------------------------------------------------------------------------------
// -------------------:/::-------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// SPDX-License-Identifier: MIT
// $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $
// $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $
// $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $
// $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $
// $ phunkE NFT series: money in authentic
// $ quote: "be authentic, make money"
// $ critique: "monetize authenticity, erode authenticity"
// $ twitter: https://twitter.com/phunkE_0tx
// $ contract: thanks to cool cats, wicked craniums, sewer rats, forgotten runes for the inspiration
// $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $
// $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $
// $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $
// $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $
// File: @openzeppelin/contracts/utils/Context.sol
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) {
return msg.data;
}
}
// File: @openzeppelin/contracts/utils/introspection/IERC165.sol
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File: @openzeppelin/contracts/token/ERC721/IERC721.sol
pragma solidity ^0.8.0;
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol
pragma solidity ^0.8.0;
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol
pragma solidity ^0.8.0;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
// File: @openzeppelin/contracts/utils/introspection/ERC165.sol
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
pragma solidity ^0.8.0;
/**
* @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) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @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");
(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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
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
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: @openzeppelin/contracts/utils/Strings.sol
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
// File: @openzeppelin/contracts/token/ERC721/ERC721.sol
pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` 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 tokenId
) internal virtual {}
}
// File: @openzeppelin/contracts/access/Ownable.sol
pragma solidity ^0.8.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.
*/
abstract 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() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol
pragma solidity ^0.8.0;
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol
pragma solidity ^0.8.0;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _allTokens.length;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
super._beforeTokenTransfer(from, to, tokenId);
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = ERC721.balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
// rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
}
// File: contracts/MONEYINAUTHENTIC.sol
pragma solidity ^0.8.0;
contract MONEYINAUTHENTIC is ERC721Enumerable, Ownable {
using Strings for uint256;
string _baseTokenURI;
uint256 private _price = 0 ether;
bool public _paused = true;
// withdraw addresses
address t1 = 0xcC6A5e38c603480F23e8E70DF41F7CbcdcD40D98;
address t2 = 0x5F5e8A4BDb8141C42F0250d5A548562FA4244cc9;
// MONEYINAUTHENTIC is a free mint to avoid eroding authenticity
// 120 MONEYINAUTHENTIC NFTS, all derivative of original hand drawn artwork from phunkE
constructor(string memory baseURI) ERC721("MONEY IN AUTHENTIC", "phunkE-MIA") {
setBaseURI(baseURI);
// dev/artist gets the first 10 MIA NFTS
_safeMint( t1, 0);
_safeMint( t1, 1);
_safeMint( t1, 2);
_safeMint( t1, 3);
_safeMint( t1, 4);
_safeMint( t2, 5);
_safeMint( t2, 6);
_safeMint( t2, 7);
_safeMint( t2, 8);
_safeMint( t2, 9);
}
function mintMONEYINAUTHENTIC(uint256 num) public payable {
uint256 supply = totalSupply();
require( !_paused, "Sale is not paused" );
require( num < 3, "You can freely mint a maximum of 2 MIA NFTS" );
require( supply + num < 121, "Exceeds maximum MIA NFTs supply" );
require( msg.value >= _price * num, "Ether sent is not correct" );
for(uint256 i; i < num; i++){
_safeMint( msg.sender, supply + i );
}
}
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
uint256 tokenCount = balanceOf(_owner);
uint256[] memory tokensId = new uint256[](tokenCount);
for(uint256 i; i < tokenCount; i++){
tokensId[i] = tokenOfOwnerByIndex(_owner, i);
}
return tokensId;
}
function _baseURI() internal view virtual override returns (string memory) {
return _baseTokenURI;
}
function setBaseURI(string memory baseURI) public onlyOwner {
_baseTokenURI = baseURI;
}
function getPrice() public view returns (uint256){
return _price;
}
function pause(bool val) public onlyOwner {
_paused = val;
}
function withdrawAll() public payable onlyOwner {
uint256 _each = address(this).balance / 2;
require(payable(t1).send(_each));
require(payable(t2).send(_each));
}
} | File: @openzeppelin/contracts/access/Ownable.sol* @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./ | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
}
pragma solidity ^0.8.0;
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
| 202,324 | [
1,
812,
30,
632,
3190,
94,
881,
84,
292,
267,
19,
16351,
87,
19,
3860,
19,
5460,
429,
18,
18281,
225,
13456,
1605,
1492,
8121,
279,
5337,
2006,
3325,
12860,
16,
1625,
1915,
353,
392,
2236,
261,
304,
3410,
13,
716,
848,
506,
17578,
12060,
2006,
358,
2923,
4186,
18,
2525,
805,
16,
326,
3410,
2236,
903,
506,
326,
1245,
716,
5993,
383,
1900,
326,
6835,
18,
1220,
848,
5137,
506,
3550,
598,
288,
13866,
5460,
12565,
5496,
1220,
1605,
353,
1399,
3059,
16334,
18,
2597,
903,
1221,
2319,
326,
9606,
1375,
3700,
5541,
9191,
1492,
848,
506,
6754,
358,
3433,
4186,
358,
13108,
3675,
999,
358,
326,
3410,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
17801,
6835,
14223,
6914,
353,
1772,
288,
203,
565,
1758,
3238,
389,
8443,
31,
203,
203,
565,
871,
14223,
9646,
5310,
1429,
4193,
12,
2867,
8808,
2416,
5541,
16,
1758,
8808,
394,
5541,
1769,
203,
203,
565,
445,
389,
5771,
1345,
5912,
12,
203,
3639,
1758,
628,
16,
203,
3639,
1758,
358,
16,
203,
3639,
2254,
5034,
1147,
548,
203,
97,
203,
203,
203,
683,
9454,
18035,
560,
3602,
20,
18,
28,
18,
20,
31,
203,
203,
565,
3885,
1435,
288,
203,
3639,
389,
542,
5541,
24899,
3576,
12021,
10663,
203,
565,
289,
203,
203,
565,
445,
3410,
1435,
1071,
1476,
5024,
1135,
261,
2867,
13,
288,
203,
3639,
327,
389,
8443,
31,
203,
565,
289,
203,
203,
565,
9606,
1338,
5541,
1435,
288,
203,
3639,
2583,
12,
8443,
1435,
422,
389,
3576,
12021,
9334,
315,
5460,
429,
30,
4894,
353,
486,
326,
3410,
8863,
203,
3639,
389,
31,
203,
565,
289,
203,
203,
565,
445,
1654,
8386,
5460,
12565,
1435,
1071,
5024,
1338,
5541,
288,
203,
3639,
389,
542,
5541,
12,
2867,
12,
20,
10019,
203,
565,
289,
203,
203,
565,
445,
7412,
5460,
12565,
12,
2867,
394,
5541,
13,
1071,
5024,
1338,
5541,
288,
203,
3639,
2583,
12,
2704,
5541,
480,
1758,
12,
20,
3631,
315,
5460,
429,
30,
394,
3410,
353,
326,
3634,
1758,
8863,
203,
3639,
389,
542,
5541,
12,
2704,
5541,
1769,
203,
565,
289,
203,
203,
565,
445,
389,
542,
5541,
12,
2867,
394,
5541,
13,
3238,
288,
203,
3639,
1758,
1592,
5541,
273,
389,
8443,
31,
203,
2
] |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
/**
* @dev Interface of the BEP20.
*/
interface BEP20 {
/**
* @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 `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, 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 `from` to `to` 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 from, address to, 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 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
* ====
*
* [IMPORTANT]
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
/**
* @dev This method relies on extcodesize/address.code.length, which returns 0
* for contracts in construction, since the code is only stored at the end
* of the constructor execution.
*/
return account.code.length > 0;
}
/**
* @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");
(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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) internal pure returns (bytes memory) {
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
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// 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 (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @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) {
return a + b;
}
/**
* @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 a - b;
}
/**
* @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) {
return a * b;
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting 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 a % b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
/**
* @dev Returns the integer division of two unsigned integers, reverting 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) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* 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) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
/**
* @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) {
return msg.data;
}
}
/**
* @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.
*/
abstract 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() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(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");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
/**
* @dev Interface of PancakeSwapV2 Factory.
*/
interface PancakeSwapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
/**
* @dev Interface of PancakeSwapV2 Pair.
*/
interface PancakeSwapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
/**
* @dev Interface of PancakeSwapV2 Router01.
*/
interface PancakeSwapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline)
external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline)
external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline)
external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline)
external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)
external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)
external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external payable returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external payable returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
/**
* @dev Interface of PancakeSwapV2 Router02.
*/
interface PancakeSwapV2Router02 is PancakeSwapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline)
external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)
external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
}
/**
* @dev Implementation of the Smart Contract for the MexaMy token.
*/
contract pruebasmx is BEP20, Context, Ownable, ReentrancyGuard {
using Address for address;
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isExcluded;
mapping(address => bool) private _Whitelisted;
mapping(address => bool) private _Blacklisted; //Reserved for bot or malicious accounts.
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 25e6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = "prueba3";
string private constant _symbol = "pr3";
uint256 private constant _decimals = 9;
uint256 public taxFee = 4;
uint256 private _previousTaxFee = taxFee;
uint256 public liquidityFee = 1;
uint256 private _previousLiquidityFee = liquidityFee;
uint256 public charityFee = 1;
uint256 private _previousCharityFee = charityFee;
address public CharityWallet = 0x4ef600B5353C7712D055C2d465A34E995654fDe1;
uint256 public devFee = 1; //Development & Marketing
uint256 private _previousDevFee = devFee;
address public DevelopmentWallet = 0x507338357031cA783508c13A963C56D48217d2B0;
uint256 public burnFee = 3;
uint256 private _previousBurnFee = burnFee;
address public constant Burn_Address = 0x000000000000000000000000000000000000dEaD;
uint256 public constant maxFee = 10; // taxFee + liquidtyFee + charityfee + devFee + burnFee <= 10
uint256 public constant maxTokensBurned = 5e6 * 10**9; // 20% of total supply
uint256 public maxTxAmount = 25e3 * 10**9; // 0.1% of total supply
uint256 public maxBalance = 125e3 * 10**9; // 0.5% of total supply
uint256 public numTokensSellToAddToLiquidity = 125e3 * 10**9; // 0.5% of total supply
PancakeSwapV2Router02 public pancakeswapV2Router;
address public pancakeswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
/**
* @dev Events
*/
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
event LiquidityAdded(uint256 tokenAmount, uint256 bnbAmount);
event SwapAndLiquifyStatus(string status);
event ExcludeFromFee(address account, bool value);
event IncludeInFee(address account, bool value);
event NewFees(uint256 _taxfee, uint256 _liquidityFee, uint256 _devFee, uint256 _charityFee, uint256 _burnFee);
event FeesEnabled(bool value);
event NewMaxTxAmount(uint256 amount);
event NewMaxBalance(uint256 amount);
event NewCharityWallet(address newCharityWallet);
event NewDevWallet(address newDevWallet);
event NumTokensSellToAddToLiquidity(uint256 amount);
event WhitelistedUptaded(address account, bool value);
event BlacklistedUpdated(address account, bool value);
event RecoverTokens(uint256 tokenAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor () {
_rOwned[_msgSender()] = _rTotal;
PancakeSwapV2Router02 _pancakeswapV2Router = PancakeSwapV2Router02(0xD99D1c33F9fC3444f8101754aBC46c52416550D1);
//0xD99D1c33F9fC3444f8101754aBC46c52416550D1 //tesnet
/**
* @dev Create a PancakeSwap Pair for this new token.
*/
pancakeswapV2Pair = PancakeSwapV2Factory(_pancakeswapV2Router.factory())
.createPair(address(this), _pancakeswapV2Router.WETH());
/**
* @dev Set the rest of the contract variables .
*/
pancakeswapV2Router = _pancakeswapV2Router;
/**
* @dev Exclude owner and this contract from Fee.
*/
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[address(CharityWallet)] = true;
_isExcludedFromFee[address(DevelopmentWallet)] = true;
/**
* @dev Whitelisted.
*/
_Whitelisted[owner()] = true;
_Whitelisted[address(this)] = true;
_Whitelisted[address(CharityWallet)] = true;
_Whitelisted[address(DevelopmentWallet)] = true;
_Whitelisted[address(Burn_Address)] = true;
_Whitelisted[address(pancakeswapV2Pair)] = true;
emit Transfer(address(0), owner(), _tTotal);
}
/**
* @dev To receive BNB from PancakeSwapV2Router02 when swapping.
*/
receive() external payable {}
/**
* @dev Returns the name of the token.
*/
function name() public pure returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public pure returns (string memory) {
return _symbol;
}
/**
* @dev Returns the decimals places of the token.
*/
function decimals() public pure returns (uint256) {
return _decimals;
}
/**
* @dev Returns total supply of token.
*/
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
/**
* @dev See balance of the address.
*/
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) external view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount , , , , , ) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount , , , , ) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns (uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeFromReward(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not included");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_rOwned[account] = _tOwned[account].mul(_getRate());
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function isExcludedFromReward(address account) external view returns (bool) {
return _isExcluded[account];
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, _getRate());
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
uint256 tFee = calculateTaxFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity);
return (tTransferAmount, tFee, tLiquidity);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rLiquidity = tLiquidity.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _takeLiquidity(uint256 tLiquidity) private {
uint256 currentRate = _getRate();
uint256 rLiquidity = tLiquidity.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity);
if (_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(taxFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(liquidityFee).div(10**2);
}
/**
* @dev Set All Fees
* Requirements: The sum of all fees must be less than or equal to maxFees.
*/
function setAllFees(uint256 _taxFee, uint256 _liquidityFee, uint256 _charityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner() {
require(_taxFee.add(_liquidityFee).add(_charityFee).add(_devFee).add(_burnFee) <= maxFee);
taxFee = _taxFee;
liquidityFee = _liquidityFee;
charityFee = _charityFee;
devFee = _devFee;
burnFee = _burnFee;
emit NewFees(_taxFee, _liquidityFee, _charityFee, _devFee, _burnFee);
}
function removeAllFee() private {
_previousTaxFee = taxFee;
_previousLiquidityFee = liquidityFee;
_previousCharityFee = charityFee;
_previousDevFee = devFee;
_previousBurnFee = burnFee;
taxFee = 0;
liquidityFee = 0;
charityFee = 0;
devFee = 0;
burnFee = 0;
}
function restoreAllFee() private {
taxFee = _previousTaxFee;
liquidityFee = _previousLiquidityFee;
charityFee = _previousCharityFee;
devFee = _previousDevFee;
burnFee = _previousBurnFee;
}
/**
*@dev Set MaxTxAmount
* Requirements: New MaxTxAmount must be greater than 0 and less than or equal to 0.1% of total supply
*/
function setMaxTxAmount(uint256 amount) external onlyOwner() {
require(amount > 0 && amount <= _tTotal.mul(1).div(1000)); // 0.1% of total supply
maxTxAmount = amount;
emit NewMaxTxAmount(amount);
}
/**
* @dev Set MaxBalance
* Requirements: New MaxBalance must be less than or equal to 0.5% of total supply
*/
function setMaxBalance(uint256 amount) external onlyOwner() {
require(amount > 0 && amount <= _tTotal.mul(5).div(1000)); // 0.5% of total supply
maxBalance = amount;
emit NewMaxBalance(amount);
}
/**
* @dev Set Number of Tokens to Add to Liquidity
* Requirements: The new amount must be greater than or equal to 0 and less than or equal to MaxTxAmount.
*/
function setNumTokensSellToAddToLiquidity(uint256 amount) external onlyOwner {
require(amount >= 0 && amount <= maxTxAmount);
numTokensSellToAddToLiquidity = amount;
emit NumTokensSellToAddToLiquidity(amount);
}
/**
* @dev Set New Address Charity.
* Requirements: The Charity Wallet cannot be the zero address.
*/
function setCharityWallet(address newCharityWallet) external onlyOwner {
require(newCharityWallet != address(0),
"BEP20: The new wallet cannot be the zero address");
CharityWallet = newCharityWallet;
emit NewCharityWallet(newCharityWallet);
}
/**
* @dev Set New address Development.
* Requirements: The Development wallet cannot be the zero address.
*/
function setDevelopmentWallet(address newDevWallet) external onlyOwner() {
require(newDevWallet != address(0),
"BEP20: The new wallet cannot be the zero address.");
DevelopmentWallet = newDevWallet;
emit NewDevWallet(newDevWallet);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function totalFees() external view returns (uint256) {
return _tFeeTotal;
}
function totalBurned() external view returns (uint256) {
return balanceOf(Burn_Address);
}
/**
* @dev The MexaMy Team may exclude certain accounts from the fees.
*/
function excludeFromFee(address account) external onlyOwner {
_isExcludedFromFee[account] = true;
emit ExcludeFromFee(account, true);
}
/**
* @dev The MexaMy Team may include certain accounts in the fees.
*/
function includeInFee(address account) external onlyOwner {
_isExcludedFromFee[account] = false;
emit IncludeInFee(account, true);
}
function isExcludedFromFee(address account) external view returns(bool) {
return _isExcludedFromFee[account];
}
/**
* @dev The Mexamy Team can whitelist specific accounts.
*/
function addToWhitelist(address account) external onlyOwner {
_Whitelisted[account] = true;
emit WhitelistedUptaded(account, true);
}
/**
* @dev The Mexamy Team can remove specific accounts of whitelist.
*/
function revomeToWhitelist(address account) external onlyOwner {
_Whitelisted[account] = false;
emit WhitelistedUptaded(account, false);
}
function Whitelisted(address account) external view returns(bool) {
return _Whitelisted[account];
}
/**
* @dev The Mexamy Team can blacklist specific accounts.
*/
function addToBlacklist(address account) external onlyOwner {
_Blacklisted[account] = true;
_isExcluded[account] = true;
_excluded.push(account);
emit BlacklistedUpdated(account, true);
}
/**
* @dev The Mexamy Team can remove specific accounts of blacklist.
*/
function removeToBlacklist(address account) external onlyOwner {
_Blacklisted[account] = false;
_isExcluded[account] = false;
_excluded.push(account);
emit BlacklistedUpdated(account, false);
}
function Blacklisted(address account) external view returns(bool) {
return _Blacklisted[account];
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "BEP20: transfer from the zero address");
require(to != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(amount <= balanceOf(from), "Transfer amount exceeds your balance");
require(!_Blacklisted[to], "Sorry, you cannot send tokens to this address.");
require(!_Blacklisted[from], "Sorry, you cannot send tokens from this address.");
if(!_Whitelisted[from] && !_Whitelisted[to]) {
require(amount <= maxTxAmount, "Transfer amount exceeds MaxTxAmount.");
require(balanceOf(to).add(amount) <= maxBalance, "Recipient exceeds MaxBalance");
}
/*
*@dev Is the token balance of this contract address over the min number of
* tokens that we need to initiate a swap + liquidity lock?
* also, don't get caught in a circular liquidity event.
* also, don't swap & liquify if sender is uniswap pair.
*/
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (overMinTokenBalance && !inSwapAndLiquify && from != pancakeswapV2Pair && swapAndLiquifyEnabled) {
contractTokenBalance = numTokensSellToAddToLiquidity;
/*
*@dev Add Liquidity.
*/
swapAndLiquify(contractTokenBalance);
}
/*
*@dev Transfer amount, it will take tax, burn, liquidity fee.
*/
_tokenTransfer(from,to,amount);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
/*
*@dev Split the contract balance into halves.
*/
uint256 half = contractTokenBalance.div(2);
uint256 otherHalf = contractTokenBalance.sub(half);
/*
*@dev Capture the contract's current BNB balance.
* this is so that we can capture exactly the amount of BNB that the
* swap creates, and not make the liquidity event include any BNB that
* has been manually sent to the contract.
*/
uint256 initialBalance = address(this).balance;
/*
*@dev Swap tokens for BNB.
*/
swapTokensForBNB(half); // <- this breaks the BNB -> MXMY swap when swap+liquify is triggered.
/*
*@dev How much BNB did we just swap into?
*/
uint256 newBalance = address(this).balance.sub(initialBalance);
/*
*@dev Add liquidity to PancakeSwap.
*/
addLiquidity(otherHalf, newBalance);
emit SwapAndLiquify(half, newBalance, otherHalf);
}
function swapTokensForBNB(uint256 tokenAmount) private returns (bool status) {
/*
*@dev Generate the PancakeSwap pair path of TOKEN -> WBNB.
*/
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = pancakeswapV2Router.WETH();
_approve(address(this), address(pancakeswapV2Router), tokenAmount);
/*
*@dev Make the swap.
*/
try pancakeswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0, /* Accept any amount of BNB*/
path,
address(this),
block.timestamp
) {
emit SwapAndLiquifyStatus("Success");
return true;
}
catch {
emit SwapAndLiquifyStatus("Failed");
return false;
}
}
function addLiquidity(uint256 tokenAmount, uint256 bnbAmount) private {
/*
*@dev Approve token transfer to cover all possible scenarios.
*/
_approve(address(this), address(pancakeswapV2Router), tokenAmount);
/*
*@dev Add the liquidity.
*/
pancakeswapV2Router.addLiquidityETH{value: bnbAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
address(this),
block.timestamp
);
emit LiquidityAdded(tokenAmount, bnbAmount);
}
function setSwapAndLiquifyEnabled(bool _enabled) external onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
/*
*@dev This method is responsible for taking all fee, if takeFee is true.
*/
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]){
removeAllFee();
}
/**
* @dev Stop token burning when maxTokensBurned is reached.
*/
uint256 tokensBurned = balanceOf(address(Burn_Address));
if(tokensBurned >= maxTokensBurned) {
burnFee = 0;
taxFee = 3;
_isExcluded[address(Burn_Address)] = true;
_excluded.push(address( Burn_Address));
}
/**
* @dev Calculate Development and Burn Amount.
*/
uint256 charityAmt = amount.mul(charityFee).div(100);
uint256 devAmt = amount.mul(devFee).div(100);
uint256 burnAmt = amount.mul(burnFee).div(100);
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, (amount.sub(charityAmt).sub(devAmt).sub(burnAmt)));
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, (amount.sub(charityAmt).sub(devAmt).sub(burnAmt)));
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, (amount.sub(charityAmt).sub(devAmt).sub(burnAmt)));
} else {
_transferStandard(sender, recipient, (amount.sub(charityAmt).sub(devAmt).sub(burnAmt)));
}
/**
* @dev Temporarily remove fees to transfer to Development Wallet and Burn Address.
*/
taxFee = 0;
liquidityFee = 0;
/**
* @dev Send transfers to Development Wallet and Burn Address.
*/
_transferStandard(sender, CharityWallet, charityAmt);
_transferStandard(sender, DevelopmentWallet, devAmt);
_transferStandard(sender, Burn_Address, burnAmt);
/**
* @dev Restore tax, liquidity and charity.
*/
taxFee = _previousTaxFee;
liquidityFee = _previousLiquidityFee;
if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient])
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
/**
* @dev Allows to recover any token BEP20 sent into the contract for error
* or in the result of the swapAndLiquify function.
* The Mexamy Team will allocate the recovered tokens for charity.
*/
function recoverTokens(address tokenAddress, uint256 tokenAmount) external nonReentrant onlyOwner {
BEP20(tokenAddress).transfer(CharityWallet, tokenAmount);
emit RecoverTokens(tokenAmount);
}
/**
* @dev Update the Router address if PancakeSwap upgrades to a newer version.
*/
function setRouterAddress(address newRouter) external onlyOwner {
PancakeSwapV2Router02 _newRouter = PancakeSwapV2Router02(newRouter);
address get_pair = PancakeSwapV2Factory(_newRouter.factory()).getPair(address(this), _newRouter.WETH());
//checks if pair already exists
if (get_pair == address(0)) {
pancakeswapV2Pair = PancakeSwapV2Factory(_newRouter.factory()).createPair(address(this), _newRouter.WETH());
}
else {
pancakeswapV2Pair = get_pair;
}
pancakeswapV2Router = _newRouter;
}
}
| * @dev Set New Address Charity. Requirements: The Charity Wallet cannot be the zero address./ | function setCharityWallet(address newCharityWallet) external onlyOwner {
require(newCharityWallet != address(0),
"BEP20: The new wallet cannot be the zero address");
CharityWallet = newCharityWallet;
emit NewCharityWallet(newCharityWallet);
}
| 6,474,673 | [
1,
694,
1166,
5267,
3703,
560,
18,
29076,
30,
1021,
3703,
560,
20126,
2780,
506,
326,
3634,
1758,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
444,
2156,
560,
16936,
12,
2867,
394,
2156,
560,
16936,
13,
3903,
1338,
5541,
288,
203,
3639,
2583,
12,
2704,
2156,
560,
16936,
480,
1758,
12,
20,
3631,
203,
3639,
315,
5948,
52,
3462,
30,
1021,
394,
9230,
2780,
506,
326,
3634,
1758,
8863,
203,
3639,
3703,
560,
16936,
273,
394,
2156,
560,
16936,
31,
203,
3639,
3626,
1166,
2156,
560,
16936,
12,
2704,
2156,
560,
16936,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/1/0xC4eF943b7c2f6b387b37689f1e9fa6ecB738845d/sources/contracts/compounder/rewardHandlers/BalancerSwapsHandler.sol | ---------------------------------------------------------------- Types ---------------------------------------------------------------- | contract BalancerSwapsHandler is HandlerBase {
using SafeERC20 for IERC20;
pragma solidity 0.8.11;
import { SafeERC20 } from "@openzeppelin/contracts-0.8/token/ERC20/utils/SafeERC20.sol";
import { IERC20 } from "@openzeppelin/contracts-0.8/token/ERC20/IERC20.sol";
import { IBalancerVault, IAsset } from "../../interfaces/balancer/IBalancerCore.sol";
import { HandlerBase } from "./HandlerBase.sol";
struct SwapPath {
bytes32[] poolIds;
address[] assetsIn;
}
SwapPath internal swapPath;
constructor(
address _token,
address _strategy,
address _balVault,
address _wethToken,
SwapPath memory _swapPath
) HandlerBase(_token, _strategy, _balVault, _wethToken) {
swapPath = _swapPath;
}
function getSwapPath() external view returns (SwapPath memory) {
return swapPath;
}
function _swapTokenToWEth(uint256 _amount) internal {
uint256 len = swapPath.poolIds.length;
IBalancerVault.BatchSwapStep[] memory swaps = new IBalancerVault.BatchSwapStep[](len);
IAsset[] memory zapAssets = new IAsset[](len + 1);
int256[] memory limits = new int256[](len + 1);
for (uint256 i = 0; i < len; i++) {
swaps[i] = IBalancerVault.BatchSwapStep({
poolId: swapPath.poolIds[i],
assetInIndex: i,
assetOutIndex: i + 1,
amount: i == 0 ? _amount : 0,
userData: new bytes(0)
});
zapAssets[i] = IAsset(swapPath.assetsIn[i]);
limits[i] = int256(i == 0 ? _amount : 0);
}
limits[len] = type(int256).max;
balVault.batchSwap(
IBalancerVault.SwapKind.GIVEN_IN,
swaps,
zapAssets,
_createSwapFunds(),
limits,
block.timestamp + 1
);
}
function _swapTokenToWEth(uint256 _amount) internal {
uint256 len = swapPath.poolIds.length;
IBalancerVault.BatchSwapStep[] memory swaps = new IBalancerVault.BatchSwapStep[](len);
IAsset[] memory zapAssets = new IAsset[](len + 1);
int256[] memory limits = new int256[](len + 1);
for (uint256 i = 0; i < len; i++) {
swaps[i] = IBalancerVault.BatchSwapStep({
poolId: swapPath.poolIds[i],
assetInIndex: i,
assetOutIndex: i + 1,
amount: i == 0 ? _amount : 0,
userData: new bytes(0)
});
zapAssets[i] = IAsset(swapPath.assetsIn[i]);
limits[i] = int256(i == 0 ? _amount : 0);
}
limits[len] = type(int256).max;
balVault.batchSwap(
IBalancerVault.SwapKind.GIVEN_IN,
swaps,
zapAssets,
_createSwapFunds(),
limits,
block.timestamp + 1
);
}
function _swapTokenToWEth(uint256 _amount) internal {
uint256 len = swapPath.poolIds.length;
IBalancerVault.BatchSwapStep[] memory swaps = new IBalancerVault.BatchSwapStep[](len);
IAsset[] memory zapAssets = new IAsset[](len + 1);
int256[] memory limits = new int256[](len + 1);
for (uint256 i = 0; i < len; i++) {
swaps[i] = IBalancerVault.BatchSwapStep({
poolId: swapPath.poolIds[i],
assetInIndex: i,
assetOutIndex: i + 1,
amount: i == 0 ? _amount : 0,
userData: new bytes(0)
});
zapAssets[i] = IAsset(swapPath.assetsIn[i]);
limits[i] = int256(i == 0 ? _amount : 0);
}
limits[len] = type(int256).max;
balVault.batchSwap(
IBalancerVault.SwapKind.GIVEN_IN,
swaps,
zapAssets,
_createSwapFunds(),
limits,
block.timestamp + 1
);
}
zapAssets[len] = IAsset(WETH_TOKEN);
function setApprovals() external {
IERC20(token).safeApprove(address(balVault), 0);
IERC20(token).safeApprove(address(balVault), type(uint256).max);
}
function sell() external override onlyStrategy {
_swapTokenToWEth(IERC20(token).balanceOf(address(this)));
IERC20(WETH_TOKEN).safeTransfer(strategy, IERC20(WETH_TOKEN).balanceOf(address(this)));
}
}
| 9,231,916 | [
1,
5802,
7658,
13420,
18753,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
605,
5191,
6050,
6679,
1503,
353,
4663,
2171,
288,
203,
565,
1450,
14060,
654,
39,
3462,
364,
467,
654,
39,
3462,
31,
203,
203,
203,
683,
9454,
18035,
560,
374,
18,
28,
18,
2499,
31,
203,
5666,
288,
14060,
654,
39,
3462,
289,
628,
8787,
3190,
94,
881,
84,
292,
267,
19,
16351,
87,
17,
20,
18,
28,
19,
2316,
19,
654,
39,
3462,
19,
5471,
19,
9890,
654,
39,
3462,
18,
18281,
14432,
203,
5666,
288,
467,
654,
39,
3462,
289,
628,
8787,
3190,
94,
881,
84,
292,
267,
19,
16351,
87,
17,
20,
18,
28,
19,
2316,
19,
654,
39,
3462,
19,
45,
654,
39,
3462,
18,
18281,
14432,
203,
5666,
288,
467,
6444,
12003,
16,
467,
6672,
289,
628,
315,
16644,
15898,
19,
18770,
19,
45,
6444,
4670,
18,
18281,
14432,
203,
5666,
288,
4663,
2171,
289,
628,
25165,
1503,
2171,
18,
18281,
14432,
203,
565,
1958,
12738,
743,
288,
203,
3639,
1731,
1578,
8526,
2845,
2673,
31,
203,
3639,
1758,
8526,
7176,
382,
31,
203,
565,
289,
203,
565,
12738,
743,
2713,
7720,
743,
31,
203,
203,
565,
3885,
12,
203,
3639,
1758,
389,
2316,
16,
203,
3639,
1758,
389,
14914,
16,
203,
3639,
1758,
389,
70,
287,
12003,
16,
203,
3639,
1758,
389,
91,
546,
1345,
16,
203,
3639,
12738,
743,
3778,
389,
22270,
743,
203,
565,
262,
4663,
2171,
24899,
2316,
16,
389,
14914,
16,
389,
70,
287,
12003,
16,
389,
91,
546,
1345,
13,
288,
203,
3639,
7720,
743,
273,
389,
22270,
743,
31,
203,
565,
2
] |
pragma solidity ^0.4.25;
/**
EN:
MultiEther contract: returns 110-120% of each investment!
Automatic payouts!
No bugs, no backdoors, NO OWNER - fully automatic!
Made and checked by professionals!
1. Send any sum to smart contract address
- sum from 0.01 ETH
- min 280000 gas limit
- you are added to a queue
2. Wait a little bit
3. ...
4. PROFIT! You have got 110-120%
How is that?
1. The first investor in the queue (you will become the
first in some time) receives next investments until
it become 110-120% of his initial investment.
2. You will receive payments in several parts or all at once
3. Once you receive 110-120% of your initial investment you are
removed from the queue.
4. You can make only one active deposit
5. The balance of this contract should normally be 0 because
all the money are immediately go to payouts
So the last pays to the first (or to several first ones
if the deposit big enough) and the investors paid 110-120% are removed from the queue
new investor --| brand new investor --|
investor5 | new investor |
investor4 | =======> investor5 |
investor3 | investor4 |
(part. paid) investor2 <| investor3 |
(fully paid) investor1 <-| investor2 <----| (pay until 110-120%)
==> Limits: <==
Total invested: up to 20ETH
Multiplier: 120%
Maximum deposit: 1ETH
Total invested: from 20 to 50ETH
Multiplier: 117%
Maximum deposit: 1.2ETH
Total invested: from 50 to 100ETH
Multiplier: 115%
Maximum deposit: 1.4ETH
Total invested: from 100 to 200ETH
Multiplier: 113%
Maximum deposit: 1.7ETH
Total invested: from 200ETH
Multiplier: 110%
Maximum deposit: 2ETH
*/
/**
RU:
ะะพะฝััะฐะบั MultiEther: ะฒะพะทะฒัะฐัะฐะตั 110-120% ะพั ะฒะฐัะตะณะพ ะดะตะฟะพะทะธัะฐ!
ะะฒัะพะผะฐัะธัะตัะบะธะต ะฒัะฟะปะฐัั!
ะะตะท ะพัะธะฑะพะบ, ะดัั, ะฐะฒัะพะผะฐัะธัะตัะบะธะน - ะดะปั ะฒัะฟะปะฐั ะะ ะะฃะะะ ะฐะดะผะธะฝะธัััะฐัะธั!
ะกะพะทะดะฐะฝ ะธ ะฟัะพะฒะตัะตะฝ ะฟัะพัะตััะธะพะฝะฐะปะฐะผะธ!
1. ะะพัะปะธัะต ะปัะฑัั ะฝะตะฝัะปะตะฒัั ััะผะผั ะฝะฐ ะฐะดัะตั ะบะพะฝััะฐะบัะฐ
- ััะผะผะฐ ะพั 0.01 ETH
- gas limit ะผะธะฝะธะผัะผ 280000
- ะฒั ะฒััะฐะฝะตัะต ะฒ ะพัะตัะตะดั
2. ะะตะผะฝะพะณะพ ะฟะพะดะพะถะดะธัะต
3. ...
4. PROFIT! ะะฐะผ ะฟัะธัะปะพ 110-120% ะพั ะฒะฐัะตะณะพ ะดะตะฟะพะทะธัะฐ.
ะะฐะบ ััะพ ะฒะพะทะผะพะถะฝะพ?
1. ะะตัะฒัะน ะธะฝะฒะตััะพั ะฒ ะพัะตัะตะดะธ (ะฒั ััะฐะฝะตัะต ะฟะตัะฒัะผ ะพัะตะฝั ัะบะพัะพ) ะฟะพะปััะฐะตั ะฒัะฟะปะฐัั ะพั
ะฝะพะฒัั
ะธะฝะฒะตััะพัะพะฒ ะดะพ ัะตั
ะฟะพั, ะฟะพะบะฐ ะฝะต ะฟะพะปััะธั 110-120% ะพั ัะฒะพะตะณะพ ะดะตะฟะพะทะธัะฐ
2. ะัะฟะปะฐัั ะผะพะณัั ะฟัะธั
ะพะดะธัั ะฝะตัะบะพะปัะบะธะผะธ ัะฐัััะผะธ ะธะปะธ ะฒัะต ััะฐะทั
3. ะะฐะบ ัะพะปัะบะพ ะฒั ะฟะพะปััะฐะตัะต 110-120% ะพั ะฒะฐัะตะณะพ ะดะตะฟะพะทะธัะฐ, ะฒั ัะดะฐะปัะตัะตัั ะธะท ะพัะตัะตะดะธ
4. ะฃ ะฒะฐั ะผะพะถะตั ะฑััั ัะพะปัะบะพ ะพะดะธะฝ ะฐะบัะธะฒะฝัะน ะฒะบะปะฐะด
5. ะะฐะปะฐะฝั ััะพะณะพ ะบะพะฝััะฐะบัะฐ ะดะพะปะถะตะฝ ะพะฑััะฝะพ ะฑััั ะฒ ัะฐะนะพะฝะต 0, ะฟะพัะพะผั ััะพ ะฒัะต ะฟะพัััะฟะปะตะฝะธั
ััะฐะทั ะถะต ะฝะฐะฟัะฐะฒะปััััั ะฝะฐ ะฒัะฟะปะฐัั
ะขะฐะบะธะผ ะพะฑัะฐะทะพะผ, ะฟะพัะปะตะดะฝะธะต ะฟะปะฐััั ะฟะตัะฒัะผ, ะธ ะธะฝะฒะตััะพัั, ะดะพััะธะณัะธะต ะฒัะฟะปะฐั 110-120% ะพั ะดะตะฟะพะทะธัะฐ,
ัะดะฐะปััััั ะธะท ะพัะตัะตะดะธ, ััััะฟะฐั ะผะตััะพ ะพััะฐะปัะฝัะผ
ะฝะพะฒัะน ะธะฝะฒะตััะพั --| ัะพะฒัะตะผ ะฝะพะฒัะน ะธะฝะฒะตััะพั --|
ะธะฝะฒะตััะพั5 | ะฝะพะฒัะน ะธะฝะฒะตััะพั |
ะธะฝะฒะตััะพั4 | =======> ะธะฝะฒะตััะพั5 |
ะธะฝะฒะตััะพั3 | ะธะฝะฒะตััะพั4 |
(ัะฐัั. ะฒัะฟะปะฐัะฐ) ะธะฝะฒะตััะพั2 <| ะธะฝะฒะตััะพั3 |
(ะฟะพะปะฝะฐั ะฒัะฟะปะฐัะฐ) ะธะฝะฒะตััะพั1 <-| ะธะฝะฒะตััะพั2 <----| (ะดะพะฟะปะฐัะฐ ะดะพ 110-120%)
==> ะะธะผะธัั: <==
ะัะตะณะพ ะธะฝะฒะตััะธัะพะฒะฐะฝะพ: ะดะพ 20ETH
ะัะพัะธั: 120%
ะะฐะบัะธะผะฐะปัะฝัะน ะฒะบะปะฐะด: 1ETH
ะัะตะณะพ ะธะฝะฒะตััะธัะพะฒะฐะฝะพ: ะพั 20 ะดะพ 50ETH
ะัะพัะธั: 117%
ะะฐะบัะธะผะฐะปัะฝัะน ะฒะบะปะฐะด: 1.2ETH
ะัะตะณะพ ะธะฝะฒะตััะธัะพะฒะฐะฝะพ: ะพั 50 ะดะพ 100ETH
ะัะพัะธั: 115%
ะะฐะบัะธะผะฐะปัะฝัะน ะฒะบะปะฐะด: 1.4ETH
ะัะตะณะพ ะธะฝะฒะตััะธัะพะฒะฐะฝะพ: ะพั 100 ะดะพ 200ETH
ะัะพัะธั: 113%
ะะฐะบัะธะผะฐะปัะฝัะน ะฒะบะปะฐะด: 1.7ETH
ะัะตะณะพ ะธะฝะฒะตััะธัะพะฒะฐะฝะพ: ะฑะพะปะตะต 200ETH
ะัะพัะธั: 110%
ะะฐะบัะธะผะฐะปัะฝัะน ะฒะบะปะฐะด: 2ETH
*/
contract MultiEther {
//The deposit structure holds all the info about the deposit made
struct Deposit {
address depositor; // The depositor address
uint deposit; // The deposit amount
uint payout; // Amount already paid
}
Deposit[] public queue; // The queue
mapping (address => uint) public depositNumber; // investor deposit index
uint public currentReceiverIndex; // The index of the depositor in the queue
uint public totalInvested; // Total invested amount
address public support = msg.sender;
uint public amountForSupport;
//This function receives all the deposits
//stores them and make immediate payouts
function () public payable {
require(block.number >= 6661266);
if(msg.value > 0){
require(gasleft() >= 250000); // We need gas to process queue
require(msg.value >= 0.01 ether && msg.value <= calcMaxDeposit()); // Too small and too big deposits are not accepted
require(depositNumber[msg.sender] == 0); // Investor should not already be in the queue
// Add the investor into the queue
queue.push( Deposit(msg.sender, msg.value, 0) );
depositNumber[msg.sender] = queue.length;
totalInvested += msg.value;
// In total, no more than 10 ETH can be sent to support the project
if (amountForSupport < 10 ether) {
uint fee = msg.value / 5;
amountForSupport += fee;
support.transfer(fee);
}
// Pay to first investors in line
pay();
}
}
// Used to pay to current investors
// Each new transaction processes 1 - 4+ investors in the head of queue
// depending on balance and gas left
function pay() internal {
uint money = address(this).balance;
uint multiplier = calcMultiplier();
// We will do cycle on the queue
for (uint i = 0; i < queue.length; i++){
uint idx = currentReceiverIndex + i; //get the index of the currently first investor
Deposit storage dep = queue[idx]; // get the info of the first investor
uint totalPayout = dep.deposit * multiplier / 100;
uint leftPayout;
if (totalPayout > dep.payout) {
leftPayout = totalPayout - dep.payout;
}
if (money >= leftPayout) { //If we have enough money on the contract to fully pay to investor
if (leftPayout > 0) {
dep.depositor.send(leftPayout); // Send money to him
money -= leftPayout;
}
// this investor is fully paid, so remove him
depositNumber[dep.depositor] = 0;
delete queue[idx];
} else{
// Here we don't have enough money so partially pay to investor
dep.depositor.send(money); // Send to him everything we have
dep.payout += money; // Update the payout amount
break; // Exit cycle
}
if (gasleft() <= 55000) { // Check the gas left. If it is low, exit the cycle
break; // The next investor will process the line further
}
}
currentReceiverIndex += i; //Update the index of the current first investor
}
// Get current queue size
function getQueueLength() public view returns (uint) {
return queue.length - currentReceiverIndex;
}
// Get max deposit for your investment
function calcMaxDeposit() public view returns (uint) {
if (totalInvested <= 20 ether) {
return 1 ether;
} else if (totalInvested <= 50 ether) {
return 1.2 ether;
} else if (totalInvested <= 100 ether) {
return 1.4 ether;
} else if (totalInvested <= 200 ether) {
return 1.7 ether;
} else {
return 2 ether;
}
}
// How many percent for your deposit to be multiplied at now
function calcMultiplier() public view returns (uint) {
if (totalInvested <= 20 ether) {
return 120;
} else if (totalInvested <= 50 ether) {
return 117;
} else if (totalInvested <= 100 ether) {
return 115;
} else if (totalInvested <= 200 ether) {
return 113;
} else {
return 110;
}
}
} | Send to him everything we have
| dep.depositor.send(money); | 906,009 | [
1,
3826,
358,
366,
381,
7756,
732,
1240,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
7734,
5993,
18,
323,
1724,
280,
18,
4661,
12,
2586,
402,
1769,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/80001/0x4E17B959835EEF6C789a7F2feA330A9df84310f8/sources/_xaya/democrit-evm/contracts/Democrit.sol | * @dev Computes the total cost in WCHI sats that a given buy, taking pool fees into account, will be./ | function getTotalBuyCost (uint remainingAmount, uint totalSats, uint64 relFee,
uint amountBought)
public view returns (uint)
{
if (amountBought == 0)
return 0;
uint sats = getSatsForPurchase (remainingAmount, totalSats, amountBought);
uint fee = getPoolFee (relFee, sats);
return sats + fee;
}
| 9,449,048 | [
1,
10743,
326,
2078,
6991,
316,
678,
1792,
45,
272,
2323,
716,
279,
864,
30143,
16,
13763,
2845,
1656,
281,
1368,
2236,
16,
903,
506,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
225,
445,
12831,
38,
9835,
8018,
261,
11890,
4463,
6275,
16,
2254,
2078,
55,
2323,
16,
2254,
1105,
1279,
14667,
16,
203,
18701,
2254,
3844,
13809,
9540,
13,
203,
1377,
1071,
1476,
1135,
261,
11890,
13,
203,
225,
288,
203,
565,
309,
261,
8949,
13809,
9540,
422,
374,
13,
203,
1377,
327,
374,
31,
203,
203,
565,
2254,
272,
2323,
273,
1322,
2323,
1290,
23164,
261,
17956,
6275,
16,
2078,
55,
2323,
16,
3844,
13809,
9540,
1769,
203,
565,
2254,
14036,
273,
28575,
14667,
261,
2878,
14667,
16,
272,
2323,
1769,
203,
565,
327,
272,
2323,
397,
14036,
31,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/42220/0x1168b2135BD2f6DeC0afFcE9bd61118052605B9A/sources/contracts/CarbonCreditTokenFactory.sol | @author FlowCarbon LLC @title A Carbon Credit Token Factory | contract CarbonCreditTokenFactory is AbstractFactory {
using ClonesUpgradeable for address;
CarbonCreditBundleTokenFactory public carbonCreditBundleTokenFactory;
pragma solidity 0.8.13;
constructor (CarbonCreditToken implementationContract_, address owner_) {
swapImplementationContract(address(implementationContract_));
transferOwnership(owner_);
}
function setCarbonCreditBundleTokenFactory(CarbonCreditBundleTokenFactory carbonCreditBundleTokenFactory_) external onlyOwner {
carbonCreditBundleTokenFactory = carbonCreditBundleTokenFactory_;
}
function createCarbonCreditToken(
string memory name_,
string memory symbol_,
CarbonCreditToken.TokenDetails memory details_,
ICarbonCreditPermissionList permissionList_,
address owner_)
onlyOwner external returns (address)
{
require(address(carbonCreditBundleTokenFactory) != address(0), 'bundle token factory is not set');
CarbonCreditToken token = CarbonCreditToken(implementationContract.clone());
token.initialize(name_, symbol_, details_, permissionList_, owner_, carbonCreditBundleTokenFactory);
finalizeCreation(address(token));
return address(token);
}
}
| 16,336,477 | [
1,
5249,
39,
11801,
511,
13394,
225,
432,
13353,
30354,
3155,
7822,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
13353,
16520,
1345,
1733,
353,
4115,
1733,
288,
203,
203,
565,
1450,
3905,
5322,
10784,
429,
364,
1758,
31,
203,
203,
565,
13353,
16520,
3405,
1345,
1733,
1071,
28755,
16520,
3405,
1345,
1733,
31,
203,
203,
683,
9454,
18035,
560,
374,
18,
28,
18,
3437,
31,
203,
565,
3885,
261,
39,
11801,
16520,
1345,
4471,
8924,
67,
16,
1758,
3410,
67,
13,
288,
203,
3639,
7720,
13621,
8924,
12,
2867,
12,
30810,
8924,
67,
10019,
203,
3639,
7412,
5460,
12565,
12,
8443,
67,
1769,
203,
565,
289,
203,
203,
565,
445,
11440,
11801,
16520,
3405,
1345,
1733,
12,
39,
11801,
16520,
3405,
1345,
1733,
28755,
16520,
3405,
1345,
1733,
67,
13,
3903,
1338,
5541,
288,
203,
3639,
28755,
16520,
3405,
1345,
1733,
273,
28755,
16520,
3405,
1345,
1733,
67,
31,
203,
565,
289,
203,
203,
565,
445,
752,
39,
11801,
16520,
1345,
12,
203,
3639,
533,
3778,
508,
67,
16,
203,
3639,
533,
3778,
3273,
67,
16,
203,
3639,
13353,
16520,
1345,
18,
1345,
3790,
3778,
3189,
67,
16,
203,
3639,
26899,
11801,
16520,
5041,
682,
4132,
682,
67,
16,
203,
3639,
1758,
3410,
67,
13,
203,
565,
1338,
5541,
3903,
1135,
261,
2867,
13,
203,
565,
288,
203,
3639,
2583,
12,
2867,
12,
71,
11801,
16520,
3405,
1345,
1733,
13,
480,
1758,
12,
20,
3631,
296,
9991,
1147,
3272,
353,
486,
444,
8284,
203,
3639,
13353,
16520,
1345,
1147,
273,
13353,
16520,
1345,
12,
30810,
8924,
18,
14056,
10663,
203,
3639,
1147,
18,
11160,
12,
529,
67,
16,
3273,
67,
16,
3189,
2
] |
./full_match/1/0x19748a349a0c55CA10FeCcD426081212DE2D19E4/sources/contracts/alloyx/core/AlloyxVault.sol | * @notice If address is whitelisted/ | modifier isWhitelisted() {
require(config.getWhitelist().isUserWhitelisted(msg.sender), "not whitelisted");
_;
}
| 3,069,251 | [
1,
2047,
1758,
353,
26944,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
225,
9606,
353,
18927,
329,
1435,
288,
203,
565,
2583,
12,
1425,
18,
588,
18927,
7675,
291,
1299,
18927,
329,
12,
3576,
18,
15330,
3631,
315,
902,
26944,
8863,
203,
565,
389,
31,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
contract KeeperBase {
/**
* @notice method that allows it to be simulated via eth_call by checking that
* the sender is the zero address.
*/
function preventExecution()
internal
view
{
require(tx.origin == address(0), "only for simulated backend");
}
/**
* @notice modifier that allows it to be simulated via eth_call by checking
* that the sender is the zero address.
*/
modifier cannotExecute()
{
preventExecution();
_;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "@chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol";
import "@chainlink/contracts/src/v0.7/interfaces/LinkTokenInterface.sol";
import "@chainlink/contracts/src/v0.7/vendor/SafeMathChainlink.sol";
import "./vendor/Owned.sol";
import "./vendor/Address.sol";
import "./vendor/Pausable.sol";
import "./vendor/ReentrancyGuard.sol";
import "./vendor/SignedSafeMath.sol";
import "./SafeMath96.sol";
import "./KeeperBase.sol";
import "./KeeperCompatibleInterface.sol";
import "./KeeperRegistryInterface.sol";
/**
* @notice Registry for adding work for Chainlink Keepers to perform on client
* contracts. Clients must support the Upkeep interface.
*/
contract KeeperRegistry is
Owned,
KeeperBase,
ReentrancyGuard,
Pausable,
KeeperRegistryExecutableInterface
{
using Address for address;
using SafeMathChainlink for uint256;
using SafeMath96 for uint96;
using SignedSafeMath for int256;
address constant private ZERO_ADDRESS = address(0);
address constant private IGNORE_ADDRESS = 0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF;
bytes4 constant private CHECK_SELECTOR = KeeperCompatibleInterface.checkUpkeep.selector;
bytes4 constant private PERFORM_SELECTOR = KeeperCompatibleInterface.performUpkeep.selector;
uint256 constant private CALL_GAS_MAX = 2_500_000;
uint256 constant private CALL_GAS_MIN = 2_300;
uint256 constant private CANCELATION_DELAY = 50;
uint256 constant private CUSHION = 5_000;
uint256 constant private REGISTRY_GAS_OVERHEAD = 80_000;
uint256 constant private PPB_BASE = 1_000_000_000;
uint64 constant private UINT64_MAX = 2**64 - 1;
uint96 constant private LINK_TOTAL_SUPPLY = 1e27;
uint256 private s_upkeepCount;
uint256[] private s_canceledUpkeepList;
address[] private s_keeperList;
mapping(uint256 => Upkeep) private s_upkeep;
mapping(address => KeeperInfo) private s_keeperInfo;
mapping(address => address) private s_proposedPayee;
mapping(uint256 => bytes) private s_checkData;
Config private s_config;
int256 private s_fallbackGasPrice; // not in config object for gas savings
int256 private s_fallbackLinkPrice; // not in config object for gas savings
LinkTokenInterface public immutable LINK;
AggregatorV3Interface public immutable LINK_ETH_FEED;
AggregatorV3Interface public immutable FAST_GAS_FEED;
address private s_registrar;
struct Upkeep {
address target;
uint32 executeGas;
uint96 balance;
address admin;
uint64 maxValidBlocknumber;
address lastKeeper;
}
struct KeeperInfo {
address payee;
uint96 balance;
bool active;
}
struct Config {
uint32 paymentPremiumPPB;
uint24 blockCountPerTurn;
uint32 checkGasLimit;
uint24 stalenessSeconds;
uint16 gasCeilingMultiplier;
}
struct PerformParams {
address from;
uint256 id;
bytes performData;
}
event UpkeepRegistered(
uint256 indexed id,
uint32 executeGas,
address admin
);
event UpkeepPerformed(
uint256 indexed id,
bool indexed success,
address indexed from,
uint96 payment,
bytes performData
);
event UpkeepCanceled(
uint256 indexed id,
uint64 indexed atBlockHeight
);
event FundsAdded(
uint256 indexed id,
address indexed from,
uint96 amount
);
event FundsWithdrawn(
uint256 indexed id,
uint256 amount,
address to
);
event ConfigSet(
uint32 paymentPremiumPPB,
uint24 blockCountPerTurn,
uint32 checkGasLimit,
uint24 stalenessSeconds,
uint16 gasCeilingMultiplier,
int256 fallbackGasPrice,
int256 fallbackLinkPrice
);
event KeepersUpdated(
address[] keepers,
address[] payees
);
event PaymentWithdrawn(
address indexed keeper,
uint256 indexed amount,
address indexed to,
address payee
);
event PayeeshipTransferRequested(
address indexed keeper,
address indexed from,
address indexed to
);
event PayeeshipTransferred(
address indexed keeper,
address indexed from,
address indexed to
);
event RegistrarChanged(
address indexed from,
address indexed to
);
/**
* @param link address of the LINK Token
* @param linkEthFeed address of the LINK/ETH price feed
* @param fastGasFeed address of the Fast Gas price feed
* @param paymentPremiumPPB payment premium rate oracles receive on top of
* being reimbursed for gas, measured in parts per billion
* @param blockCountPerTurn number of blocks each oracle has during their turn to
* perform upkeep before it will be the next keeper's turn to submit
* @param checkGasLimit gas limit when checking for upkeep
* @param stalenessSeconds number of seconds that is allowed for feed data to
* be stale before switching to the fallback pricing
* @param gasCeilingMultiplier multiplier to apply to the fast gas feed price
* when calculating the payment ceiling for keepers
* @param fallbackGasPrice gas price used if the gas price feed is stale
* @param fallbackLinkPrice LINK price used if the LINK price feed is stale
*/
constructor(
address link,
address linkEthFeed,
address fastGasFeed,
uint32 paymentPremiumPPB,
uint24 blockCountPerTurn,
uint32 checkGasLimit,
uint24 stalenessSeconds,
uint16 gasCeilingMultiplier,
int256 fallbackGasPrice,
int256 fallbackLinkPrice
) {
LINK = LinkTokenInterface(link);
LINK_ETH_FEED = AggregatorV3Interface(linkEthFeed);
FAST_GAS_FEED = AggregatorV3Interface(fastGasFeed);
setConfig(
paymentPremiumPPB,
blockCountPerTurn,
checkGasLimit,
stalenessSeconds,
gasCeilingMultiplier,
fallbackGasPrice,
fallbackLinkPrice
);
}
// ACTIONS
/**
* @notice adds a new upkeep
* @param target address to peform upkeep on
* @param gasLimit amount of gas to provide the target contract when
* performing upkeep
* @param admin address to cancel upkeep and withdraw remaining funds
* @param checkData data passed to the contract when checking for upkeep
*/
function registerUpkeep(
address target,
uint32 gasLimit,
address admin,
bytes calldata checkData
)
external
override
onlyOwnerOrRegistrar()
returns (
uint256 id
)
{
require(target.isContract(), "target is not a contract");
require(gasLimit >= CALL_GAS_MIN, "min gas is 2300");
require(gasLimit <= CALL_GAS_MAX, "max gas is 2500000");
id = s_upkeepCount;
s_upkeep[id] = Upkeep({
target: target,
executeGas: gasLimit,
balance: 0,
admin: admin,
maxValidBlocknumber: UINT64_MAX,
lastKeeper: address(0)
});
s_checkData[id] = checkData;
s_upkeepCount++;
emit UpkeepRegistered(id, gasLimit, admin);
return id;
}
/**
* @notice simulated by keepers via eth_call to see if the upkeep needs to be
* performed. If it does need to be performed then the call simulates the
* transaction performing upkeep to make sure it succeeds. It then eturns the
* success status along with payment information and the perform data payload.
* @param id identifier of the upkeep to check
* @param from the address to simulate performing the upkeep from
*/
function checkUpkeep(
uint256 id,
address from
)
external
override
whenNotPaused()
cannotExecute()
returns (
bytes memory performData,
uint256 maxLinkPayment,
uint256 gasLimit,
int256 gasWei,
int256 linkEth
)
{
Upkeep storage upkeep = s_upkeep[id];
gasLimit = upkeep.executeGas;
(gasWei, linkEth) = getFeedData();
maxLinkPayment = calculatePaymentAmount(gasLimit, gasWei, linkEth);
require(maxLinkPayment < upkeep.balance, "insufficient funds");
bytes memory callData = abi.encodeWithSelector(CHECK_SELECTOR, s_checkData[id]);
(
bool success,
bytes memory result
) = upkeep.target.call{gas: s_config.checkGasLimit}(callData);
require(success, "call to check target failed");
(
success,
performData
) = abi.decode(result, (bool, bytes));
require(success, "upkeep not needed");
success = performUpkeepWithParams(PerformParams({
from: from,
id: id,
performData: performData
}));
require(success, "call to perform upkeep failed");
return (performData, maxLinkPayment, gasLimit, gasWei, linkEth);
}
/**
* @notice executes the upkeep with the perform data returned from
* checkUpkeep, validates the keeper's permissions, and pays the keeper.
* @param id identifier of the upkeep to execute the data with.
* @param performData calldata paramter to be passed to the target upkeep.
*/
function performUpkeep(
uint256 id,
bytes calldata performData
)
external
override
returns (
bool success
)
{
return performUpkeepWithParams(PerformParams({
from: msg.sender,
id: id,
performData: performData
}));
}
/**
* @notice prevent an upkeep from being performed in the future
* @param id upkeep to be canceled
*/
function cancelUpkeep(
uint256 id
)
external
override
{
uint64 maxValid = s_upkeep[id].maxValidBlocknumber;
bool notCanceled = maxValid == UINT64_MAX;
bool isOwner = msg.sender == owner;
require(notCanceled || (isOwner && maxValid > block.number), "too late to cancel upkeep");
require(isOwner|| msg.sender == s_upkeep[id].admin, "only owner or admin");
uint256 height = block.number;
if (!isOwner) {
height = height.add(CANCELATION_DELAY);
}
s_upkeep[id].maxValidBlocknumber = uint64(height);
if (notCanceled) {
s_canceledUpkeepList.push(id);
}
emit UpkeepCanceled(id, uint64(height));
}
/**
* @notice adds LINK funding for an upkeep by tranferring from the sender's
* LINK balance
* @param id upkeep to fund
* @param amount number of LINK to transfer
*/
function addFunds(
uint256 id,
uint96 amount
)
external
override
validUpkeep(id)
{
s_upkeep[id].balance = s_upkeep[id].balance.add(amount);
LINK.transferFrom(msg.sender, address(this), amount);
emit FundsAdded(id, msg.sender, amount);
}
/**
* @notice uses LINK's transferAndCall to LINK and add funding to an upkeep
* @dev safe to cast uint256 to uint96 as total LINK supply is under UINT96MAX
* @param sender the account which transferred the funds
* @param amount number of LINK transfer
*/
function onTokenTransfer(
address sender,
uint256 amount,
bytes calldata data
)
external
{
require(msg.sender == address(LINK), "only callable through LINK");
require(data.length == 32, "data must be 32 bytes");
uint256 id = abi.decode(data, (uint256));
validateUpkeep(id);
s_upkeep[id].balance = s_upkeep[id].balance.add(uint96(amount));
emit FundsAdded(id, sender, uint96(amount));
}
/**
* @notice removes funding from a cancelled upkeep
* @param id upkeep to withdraw funds from
* @param to destination address for sending remaining funds
*/
function withdrawFunds(
uint256 id,
address to
)
external
validateRecipient(to)
{
require(s_upkeep[id].admin == msg.sender, "only callable by admin");
require(s_upkeep[id].maxValidBlocknumber <= block.number, "upkeep must be canceled");
uint256 amount = s_upkeep[id].balance;
s_upkeep[id].balance = 0;
emit FundsWithdrawn(id, amount, to);
LINK.transfer(to, amount);
}
/**
* @notice recovers LINK funds improperly transfered to the registry
* @dev In principle this functionโs execution cost could exceed block
* gaslimit. However, in our anticipated deployment, the number of upkeeps and
* keepers will be low enough to avoid this problem.
*/
function recoverFunds()
external
onlyOwner()
{
uint96 locked = 0;
uint256 max = s_upkeepCount;
for (uint256 i = 0; i < max; i++) {
locked = s_upkeep[i].balance.add(locked);
}
max = s_keeperList.length;
for (uint256 i = 0; i < max; i++) {
address addr = s_keeperList[i];
locked = s_keeperInfo[addr].balance.add(locked);
}
uint256 total = LINK.balanceOf(address(this));
LINK.transfer(msg.sender, total.sub(locked));
}
/**
* @notice withdraws a keeper's payment, callable only by the keeper's payee
* @param from keeper address
* @param to address to send the payment to
*/
function withdrawPayment(
address from,
address to
)
external
validateRecipient(to)
{
KeeperInfo memory keeper = s_keeperInfo[from];
require(keeper.payee == msg.sender, "only callable by payee");
s_keeperInfo[from].balance = 0;
emit PaymentWithdrawn(from, keeper.balance, to, msg.sender);
LINK.transfer(to, keeper.balance);
}
/**
* @notice proposes the safe transfer of a keeper's payee to another address
* @param keeper address of the keeper to transfer payee role
* @param proposed address to nominate for next payeeship
*/
function transferPayeeship(
address keeper,
address proposed
)
external
{
require(s_keeperInfo[keeper].payee == msg.sender, "only callable by payee");
require(proposed != msg.sender, "cannot transfer to self");
if (s_proposedPayee[keeper] != proposed) {
s_proposedPayee[keeper] = proposed;
emit PayeeshipTransferRequested(keeper, msg.sender, proposed);
}
}
/**
* @notice accepts the safe transfer of payee role for a keeper
* @param keeper address to accept the payee role for
*/
function acceptPayeeship(
address keeper
)
external
{
require(s_proposedPayee[keeper] == msg.sender, "only callable by proposed payee");
address past = s_keeperInfo[keeper].payee;
s_keeperInfo[keeper].payee = msg.sender;
s_proposedPayee[keeper] = ZERO_ADDRESS;
emit PayeeshipTransferred(keeper, past, msg.sender);
}
/**
* @notice signals to keepers that they should not perform upkeeps until the
* contract has been unpaused
*/
function pause()
external
onlyOwner()
{
_pause();
}
/**
* @notice signals to keepers that they can perform upkeeps once again after
* having been paused
*/
function unpause()
external
onlyOwner()
{
_unpause();
}
// SETTERS
/**
* @notice updates the configuration of the registry
* @param paymentPremiumPPB payment premium rate oracles receive on top of
* being reimbursed for gas, measured in parts per billion
* @param blockCountPerTurn number of blocks an oracle should wait before
* checking for upkeep
* @param checkGasLimit gas limit when checking for upkeep
* @param stalenessSeconds number of seconds that is allowed for feed data to
* be stale before switching to the fallback pricing
* @param fallbackGasPrice gas price used if the gas price feed is stale
* @param fallbackLinkPrice LINK price used if the LINK price feed is stale
*/
function setConfig(
uint32 paymentPremiumPPB,
uint24 blockCountPerTurn,
uint32 checkGasLimit,
uint24 stalenessSeconds,
uint16 gasCeilingMultiplier,
int256 fallbackGasPrice,
int256 fallbackLinkPrice
)
onlyOwner()
public
{
s_config = Config({
paymentPremiumPPB: paymentPremiumPPB,
blockCountPerTurn: blockCountPerTurn,
checkGasLimit: checkGasLimit,
stalenessSeconds: stalenessSeconds,
gasCeilingMultiplier: gasCeilingMultiplier
});
s_fallbackGasPrice = fallbackGasPrice;
s_fallbackLinkPrice = fallbackLinkPrice;
emit ConfigSet(
paymentPremiumPPB,
blockCountPerTurn,
checkGasLimit,
stalenessSeconds,
gasCeilingMultiplier,
fallbackGasPrice,
fallbackLinkPrice
);
}
/**
* @notice update the list of keepers allowed to peform upkeep
* @param keepers list of addresses allowed to perform upkeep
* @param payees addreses corresponding to keepers who are allowed to
* move payments which have been acrued
*/
function setKeepers(
address[] calldata keepers,
address[] calldata payees
)
external
onlyOwner()
{
for (uint256 i = 0; i < s_keeperList.length; i++) {
address keeper = s_keeperList[i];
s_keeperInfo[keeper].active = false;
}
for (uint256 i = 0; i < keepers.length; i++) {
address keeper = keepers[i];
KeeperInfo storage s_keeper = s_keeperInfo[keeper];
address oldPayee = s_keeper.payee;
address newPayee = payees[i];
require(oldPayee == ZERO_ADDRESS || oldPayee == newPayee || newPayee == IGNORE_ADDRESS, "cannot change payee");
require(!s_keeper.active, "cannot add keeper twice");
s_keeper.active = true;
if (newPayee != IGNORE_ADDRESS) {
s_keeper.payee = newPayee;
}
}
s_keeperList = keepers;
emit KeepersUpdated(keepers, payees);
}
/**
* @notice update registrar
* @param registrar new registrar
*/
function setRegistrar(
address registrar
)
external
onlyOwnerOrRegistrar()
{
address previous = s_registrar;
require(registrar != previous, "Same registrar");
s_registrar = registrar;
emit RegistrarChanged(previous, registrar);
}
// GETTERS
/**
* @notice read all of the details about an upkeep
*/
function getUpkeep(
uint256 id
)
external
view
override
returns (
address target,
uint32 executeGas,
bytes memory checkData,
uint96 balance,
address lastKeeper,
address admin,
uint64 maxValidBlocknumber
)
{
Upkeep memory reg = s_upkeep[id];
return (
reg.target,
reg.executeGas,
s_checkData[id],
reg.balance,
reg.lastKeeper,
reg.admin,
reg.maxValidBlocknumber
);
}
/**
* @notice read the total number of upkeep's registered
*/
function getUpkeepCount()
external
view
override
returns (
uint256
)
{
return s_upkeepCount;
}
/**
* @notice read the current list canceled upkeep IDs
*/
function getCanceledUpkeepList()
external
view
override
returns (
uint256[] memory
)
{
return s_canceledUpkeepList;
}
/**
* @notice read the current list of addresses allowed to perform upkeep
*/
function getKeeperList()
external
view
override
returns (
address[] memory
)
{
return s_keeperList;
}
/**
* @notice read the current registrar
*/
function getRegistrar()
external
view
returns (
address
)
{
return s_registrar;
}
/**
* @notice read the current info about any keeper address
*/
function getKeeperInfo(
address query
)
external
view
override
returns (
address payee,
bool active,
uint96 balance
)
{
KeeperInfo memory keeper = s_keeperInfo[query];
return (keeper.payee, keeper.active, keeper.balance);
}
/**
* @notice read the current configuration of the registry
*/
function getConfig()
external
view
override
returns (
uint32 paymentPremiumPPB,
uint24 blockCountPerTurn,
uint32 checkGasLimit,
uint24 stalenessSeconds,
uint16 gasCeilingMultiplier,
int256 fallbackGasPrice,
int256 fallbackLinkPrice
)
{
Config memory config = s_config;
return (
config.paymentPremiumPPB,
config.blockCountPerTurn,
config.checkGasLimit,
config.stalenessSeconds,
config.gasCeilingMultiplier,
s_fallbackGasPrice,
s_fallbackLinkPrice
);
}
// PRIVATE
/**
* @dev retrieves feed data for fast gas/eth and link/eth prices. if the feed
* data is stale it uses the configured fallback price. Once a price is picked
* for gas it takes the min of gas price in the transaction or the fast gas
* price in order to reduce costs for the upkeep clients.
*/
function getFeedData()
private
view
returns (
int256 gasWei,
int256 linkEth
)
{
uint32 stalenessSeconds = s_config.stalenessSeconds;
bool staleFallback = stalenessSeconds > 0;
uint256 timestamp;
(,gasWei,,timestamp,) = FAST_GAS_FEED.latestRoundData();
if (staleFallback && stalenessSeconds < block.timestamp - timestamp) {
gasWei = s_fallbackGasPrice;
}
(,linkEth,,timestamp,) = LINK_ETH_FEED.latestRoundData();
if (staleFallback && stalenessSeconds < block.timestamp - timestamp) {
linkEth = s_fallbackLinkPrice;
}
return (gasWei, linkEth);
}
/**
* @dev calculates LINK paid for gas spent plus a configure premium percentage
*/
function calculatePaymentAmount(
uint256 gasLimit,
int256 gasWei,
int256 linkEth
)
private
view
returns (
uint96 payment
)
{
uint256 weiForGas = uint256(gasWei).mul(gasLimit.add(REGISTRY_GAS_OVERHEAD));
uint256 premium = PPB_BASE.add(s_config.paymentPremiumPPB);
uint256 total = weiForGas.mul(1e9).mul(premium).div(uint256(linkEth));
require(total <= LINK_TOTAL_SUPPLY, "payment greater than all LINK");
return uint96(total); // LINK_TOTAL_SUPPLY < UINT96_MAX
}
/**
* @dev calls target address with exactly gasAmount gas and data as calldata
* or reverts if at least gasAmount gas is not available
*/
function callWithExactGas(
uint256 gasAmount,
address target,
bytes memory data
)
private
returns (
bool success
)
{
assembly{
let g := gas()
// Compute g -= CUSHION and check for underflow
if lt(g, CUSHION) { revert(0, 0) }
g := sub(g, CUSHION)
// if g - g//64 <= gasAmount, revert
// (we subtract g//64 because of EIP-150)
if iszero(gt(sub(g, div(g, 64)), gasAmount)) { revert(0, 0) }
// solidity calls check that a contract actually exists at the destination, so we do the same
if iszero(extcodesize(target)) { revert(0, 0) }
// call and return whether we succeeded. ignore return data
success := call(gasAmount, target, 0, add(data, 0x20), mload(data), 0, 0)
}
return success;
}
/**
* @dev calls the Upkeep target with the performData param passed in by the
* keeper and the exact gas required by the Upkeep
*/
function performUpkeepWithParams(
PerformParams memory params
)
private
nonReentrant()
validUpkeep(params.id)
returns (
bool success
)
{
require(s_keeperInfo[params.from].active, "only active keepers");
Upkeep memory upkeep = s_upkeep[params.id];
uint256 gasLimit = upkeep.executeGas;
(int256 gasWei, int256 linkEth) = getFeedData();
gasWei = adjustGasPrice(gasWei);
uint96 payment = calculatePaymentAmount(gasLimit, gasWei, linkEth);
require(upkeep.balance >= payment, "insufficient payment");
require(upkeep.lastKeeper != params.from, "keepers must take turns");
uint256 gasUsed = gasleft();
bytes memory callData = abi.encodeWithSelector(PERFORM_SELECTOR, params.performData);
success = callWithExactGas(gasLimit, upkeep.target, callData);
gasUsed = gasUsed - gasleft();
payment = calculatePaymentAmount(gasUsed, gasWei, linkEth);
upkeep.balance = upkeep.balance.sub(payment);
upkeep.lastKeeper = params.from;
s_upkeep[params.id] = upkeep;
uint96 newBalance = s_keeperInfo[params.from].balance.add(payment);
s_keeperInfo[params.from].balance = newBalance;
emit UpkeepPerformed(
params.id,
success,
params.from,
payment,
params.performData
);
return success;
}
/**
* @dev ensures a upkeep is valid
*/
function validateUpkeep(
uint256 id
)
private
view
{
require(s_upkeep[id].maxValidBlocknumber > block.number, "invalid upkeep id");
}
/**
* @dev adjusts the gas price to min(ceiling, tx.gasprice)
*/
function adjustGasPrice(
int256 gasWei
)
private
view
returns(int256 adjustedPrice)
{
adjustedPrice = int256(tx.gasprice);
int256 ceiling = gasWei.mul(s_config.gasCeilingMultiplier);
if(adjustedPrice > ceiling) {
adjustedPrice = ceiling;
}
}
// MODIFIERS
/**
* @dev ensures a upkeep is valid
*/
modifier validUpkeep(
uint256 id
) {
validateUpkeep(id);
_;
}
/**
* @dev ensures that burns don't accidentally happen by sending to the zero
* address
*/
modifier validateRecipient(
address to
) {
require(to != address(0), "cannot send to zero address");
_;
}
/**
* @dev Reverts if called by anyone other than the contract owner or registrar.
*/
modifier onlyOwnerOrRegistrar() {
require(msg.sender == owner || msg.sender == s_registrar, "Only callable by owner or registrar");
_;
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0;
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
interface LinkTokenInterface {
function allowance(address owner, address spender) external view returns (uint256 remaining);
function approve(address spender, uint256 value) external returns (bool success);
function balanceOf(address owner) external view returns (uint256 balance);
function decimals() external view returns (uint8 decimalPlaces);
function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);
function increaseApproval(address spender, uint256 subtractedValue) external;
function name() external view returns (string memory tokenName);
function symbol() external view returns (string memory tokenSymbol);
function totalSupply() external view returns (uint256 totalTokensIssued);
function transfer(address to, uint256 value) external returns (bool success);
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool success);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.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 SafeMathChainlink {
/**
* @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) {
require(b <= a, "SafeMath: subtraction overflow");
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-solidity/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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
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) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
/**
* @title The Owned contract
* @notice A contract with helpers for basic contract ownership.
*/
contract Owned {
address public owner;
address private pendingOwner;
event OwnershipTransferRequested(
address indexed from,
address indexed to
);
event OwnershipTransferred(
address indexed from,
address indexed to
);
constructor() {
owner = msg.sender;
}
/**
* @dev Allows an owner to begin transferring ownership to a new address,
* pending.
*/
function transferOwnership(address _to)
external
onlyOwner()
{
pendingOwner = _to;
emit OwnershipTransferRequested(owner, _to);
}
/**
* @dev Allows an ownership transfer to be completed by the recipient.
*/
function acceptOwnership()
external
{
require(msg.sender == pendingOwner, "Must be proposed owner");
address oldOwner = owner;
owner = msg.sender;
pendingOwner = address(0);
emit OwnershipTransferred(oldOwner, msg.sender);
}
/**
* @dev Reverts if called by anyone other than the contract owner.
*/
modifier onlyOwner() {
require(msg.sender == owner, "Only callable by owner");
_;
}
}
// SPDX-License-Identifier: MIT
// github.com/OpenZeppelin/[emailย protected]
pragma solidity >=0.6.2 <0.8.0;
/**
* @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) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
/**
* @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");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
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);
}
}
}
}
// SPDX-License-Identifier: MIT
// github.com/OpenZeppelin/[emailย protected]
pragma solidity >=0.6.0 <0.8.0;
import "./Context.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
constructor () {
_paused = false;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
// SPDX-License-Identifier: MIT
// github.com/OpenZeppelin/[emailย protected]
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @title SignedSafeMath
* @dev Signed math operations with safety checks that revert on error.
*/
library SignedSafeMath {
int256 constant private _INT256_MIN = -2**255;
/**
* @dev Returns the multiplication of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
// 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;
}
require(!(a == -1 && b == _INT256_MIN), "SignedSafeMath: multiplication overflow");
int256 c = a * b;
require(c / a == b, "SignedSafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two signed 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(int256 a, int256 b) internal pure returns (int256) {
require(b != 0, "SignedSafeMath: division by zero");
require(!(b == -1 && a == _INT256_MIN), "SignedSafeMath: division overflow");
int256 c = a / b;
return c;
}
/**
* @dev Returns the subtraction of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a), "SignedSafeMath: subtraction overflow");
return c;
}
/**
* @dev Returns the addition of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a), "SignedSafeMath: addition overflow");
return c;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.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.
*
* This library is a version of Open Zeppelin's SafeMath, modified to support
* unsigned 96 bit integers.
*/
library SafeMath96 {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint96 a, uint96 b) internal pure returns (uint96) {
uint96 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(uint96 a, uint96 b) internal pure returns (uint96) {
require(b <= a, "SafeMath: subtraction overflow");
uint96 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(uint96 a, uint96 b) internal pure returns (uint96) {
// 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-solidity/pull/522
if (a == 0) {
return 0;
}
uint96 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(uint96 a, uint96 b) internal pure returns (uint96) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint96 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(uint96 a, uint96 b) internal pure returns (uint96) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
interface KeeperCompatibleInterface {
/**
* @notice method that is simulated by the keepers to see if any work actually
* needs to be performed. This method does does not actually need to be
* executable, and since it is only ever simulated it can consume lots of gas.
* @dev To ensure that it is never called, you may want to add the
* cannotExecute modifier from KeeperBase to your implementation of this
* method.
* @param checkData specified in the upkeep registration so it is always the
* same for a registered upkeep. This can easilly be broken down into specific
* arguments using `abi.decode`, so multiple upkeeps can be registered on the
* same contract and easily differentiated by the contract.
* @return upkeepNeeded boolean to indicate whether the keeper should call
* performUpkeep or not.
* @return performData bytes that the keeper should call performUpkeep with, if
* upkeep is needed. If you would like to encode data to decode later, try
* `abi.encode`.
*/
function checkUpkeep(
bytes calldata checkData
)
external
returns (
bool upkeepNeeded,
bytes memory performData
);
/**
* @notice method that is actually executed by the keepers, via the registry.
* The data returned by the checkUpkeep simulation will be passed into
* this method to actually be executed.
* @dev The input to this method should not be trusted, and the caller of the
* method should not even be restricted to any single registry. Anyone should
* be able call it, and the input should be validated, there is no guarantee
* that the data passed in is the performData returned from checkUpkeep. This
* could happen due to malicious keepers, racing keepers, or simply a state
* change while the performUpkeep transaction is waiting for confirmation.
* Always validate the data passed in.
* @param performData is the data which was passed back from the checkData
* simulation. If it is encoded, it can easily be decoded into other types by
* calling `abi.decode`. This data should not be trusted, and should be
* validated against the contract's current state.
*/
function performUpkeep(
bytes calldata performData
) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
interface KeeperRegistryBaseInterface {
function registerUpkeep(
address target,
uint32 gasLimit,
address admin,
bytes calldata checkData
) external returns (
uint256 id
);
function performUpkeep(
uint256 id,
bytes calldata performData
) external returns (
bool success
);
function cancelUpkeep(
uint256 id
) external;
function addFunds(
uint256 id,
uint96 amount
) external;
function getUpkeep(uint256 id)
external view returns (
address target,
uint32 executeGas,
bytes memory checkData,
uint96 balance,
address lastKeeper,
address admin,
uint64 maxValidBlocknumber
);
function getUpkeepCount()
external view returns (uint256);
function getCanceledUpkeepList()
external view returns (uint256[] memory);
function getKeeperList()
external view returns (address[] memory);
function getKeeperInfo(address query)
external view returns (
address payee,
bool active,
uint96 balance
);
function getConfig()
external view returns (
uint32 paymentPremiumPPB,
uint24 checkFrequencyBlocks,
uint32 checkGasLimit,
uint24 stalenessSeconds,
uint16 gasCeilingMultiplier,
int256 fallbackGasPrice,
int256 fallbackLinkPrice
);
}
/**
* @dev The view methods are not actually marked as view in the implementation
* but we want them to be easily queried off-chain. Solidity will not compile
* if we actually inherrit from this interface, so we document it here.
*/
interface KeeperRegistryInterface is KeeperRegistryBaseInterface {
function checkUpkeep(
uint256 upkeepId,
address from
)
external
view
returns (
bytes memory performData,
uint256 maxLinkPayment,
uint256 gasLimit,
int256 gasWei,
int256 linkEth
);
}
interface KeeperRegistryExecutableInterface is KeeperRegistryBaseInterface {
function checkUpkeep(
uint256 upkeepId,
address from
)
external
returns (
bytes memory performData,
uint256 maxLinkPayment,
uint256 gasLimit,
int256 gasWei,
int256 linkEth
);
}
// SPDX-License-Identifier: MIT
// github.com/OpenZeppelin/[emailย protected]
pragma solidity >=0.6.0 <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 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;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "./vendor/Owned.sol";
import "./KeeperRegistryInterface.sol";
/**
* @notice Contract to accept requests for upkeep registrations
* @dev There are 2 registration workflows in this contract
* Flow 1. auto approve OFF / manual registration - UI calls `register` function on this contract, this contract owner at a later time then manually
* calls `approve` to register upkeep and emit events to inform UI and others interested.
* Flow 2. auto approve ON / real time registration - UI calls `register` function as before, which calls the `registerUpkeep` function directly on
* keeper registry and then emits approved event to finish the flow automatically without manual intervention.
* The idea is to have same interface(functions,events) for UI or anyone using this contract irrespective of auto approve being enabled or not.
* they can just listen to `RegistrationRequested` & `RegistrationApproved` events and know the status on registrations.
*/
contract UpkeepRegistrationRequests is Owned {
bytes4 private constant REGISTER_REQUEST_SELECTOR = this.register.selector;
uint256 private s_minLINKJuels;
address public immutable LINK_ADDRESS;
struct AutoApprovedConfig {
bool enabled;
uint16 allowedPerWindow;
uint32 windowSizeInBlocks;
uint64 windowStart;
uint16 approvedInCurrentWindow;
}
AutoApprovedConfig private s_config;
KeeperRegistryBaseInterface private s_keeperRegistry;
event MinLINKChanged(uint256 from, uint256 to);
event RegistrationRequested(
bytes32 indexed hash,
string name,
bytes encryptedEmail,
address indexed upkeepContract,
uint32 gasLimit,
address adminAddress,
bytes checkData,
uint8 indexed source
);
event RegistrationApproved(
bytes32 indexed hash,
string displayName,
uint256 indexed upkeepId
);
constructor(
address LINKAddress,
uint256 minimumLINKJuels
)
{
LINK_ADDRESS = LINKAddress;
s_minLINKJuels = minimumLINKJuels;
}
//EXTERNAL
/**
* @notice register can only be called through transferAndCall on LINK contract
* @param name name of the upkeep to be registered
* @param encryptedEmail Amount of LINK sent (specified in Juels)
* @param upkeepContract address to peform upkeep on
* @param gasLimit amount of gas to provide the target contract when
* performing upkeep
* @param adminAddress address to cancel upkeep and withdraw remaining funds
* @param checkData data passed to the contract when checking for upkeep
* @param source application sending this request
*/
function register(
string memory name,
bytes calldata encryptedEmail,
address upkeepContract,
uint32 gasLimit,
address adminAddress,
bytes calldata checkData,
uint8 source
)
external
onlyLINK()
{
bytes32 hash = keccak256(msg.data);
emit RegistrationRequested(
hash,
name,
encryptedEmail,
upkeepContract,
gasLimit,
adminAddress,
checkData,
source
);
AutoApprovedConfig memory config = s_config;
// if auto approve is true send registration request to the Keeper Registry contract
if (config.enabled) {
_resetWindowIfRequired(config);
if (config.approvedInCurrentWindow < config.allowedPerWindow) {
config.approvedInCurrentWindow++;
s_config = config;
_approve(
name,
upkeepContract,
gasLimit,
adminAddress,
checkData,
hash
);
}
}
}
/**
* @dev register upkeep on KeeperRegistry contract and emit RegistrationApproved event
*/
function approve(
string memory name,
address upkeepContract,
uint32 gasLimit,
address adminAddress,
bytes calldata checkData,
bytes32 hash
)
external
onlyOwner()
{
_approve(
name,
upkeepContract,
gasLimit,
adminAddress,
checkData,
hash
);
}
/**
* @notice owner calls this function to set minimum LINK required to send registration request
* @param minimumLINKJuels minimum LINK required to send registration request
*/
function setMinLINKJuels(
uint256 minimumLINKJuels
)
external
onlyOwner()
{
emit MinLINKChanged(s_minLINKJuels, minimumLINKJuels);
s_minLINKJuels = minimumLINKJuels;
}
/**
* @notice read the minimum LINK required to send registration request
*/
function getMinLINKJuels()
external
view
returns (
uint256
)
{
return s_minLINKJuels;
}
/**
* @notice owner calls this function to set if registration requests should be sent directly to the Keeper Registry
* @param enabled setting for autoapprove registrations
* @param windowSizeInBlocks window size defined in number of blocks
* @param allowedPerWindow number of registrations that can be auto approved in above window
* @param keeperRegistry new keeper registry address
*/
function setRegistrationConfig(
bool enabled,
uint32 windowSizeInBlocks,
uint16 allowedPerWindow,
address keeperRegistry
)
external
onlyOwner()
{
s_config = AutoApprovedConfig({
enabled: enabled,
allowedPerWindow: allowedPerWindow,
windowSizeInBlocks: windowSizeInBlocks,
windowStart: 0,
approvedInCurrentWindow: 0
});
s_keeperRegistry = KeeperRegistryBaseInterface(keeperRegistry);
}
/**
* @notice read the current registration configuration
*/
function getRegistrationConfig()
external
view
returns (
bool enabled,
uint32 windowSizeInBlocks,
uint16 allowedPerWindow,
address keeperRegistry,
uint64 windowStart,
uint16 approvedInCurrentWindow
)
{
AutoApprovedConfig memory config = s_config;
return (
config.enabled,
config.windowSizeInBlocks,
config.allowedPerWindow,
address(s_keeperRegistry),
config.windowStart,
config.approvedInCurrentWindow
);
}
/**
* @notice Called when LINK is sent to the contract via `transferAndCall`
* @param amount Amount of LINK sent (specified in Juels)
* @param data Payload of the transaction
*/
function onTokenTransfer(
address, /* sender */
uint256 amount,
bytes calldata data
)
external
onlyLINK()
permittedFunctionsForLINK(data)
{
require(amount >= s_minLINKJuels, "Insufficient payment");
(bool success, ) = address(this).delegatecall(data); // calls register
require(success, "Unable to create request");
}
//PRIVATE
/**
* @dev reset auto approve window if passed end of current window
*/
function _resetWindowIfRequired(
AutoApprovedConfig memory config
)
private
{
uint64 blocksPassed = uint64(block.number - config.windowStart);
if (blocksPassed >= config.windowSizeInBlocks) {
config.windowStart = uint64(block.number);
config.approvedInCurrentWindow = 0;
s_config = config;
}
}
/**
* @dev register upkeep on KeeperRegistry contract and emit RegistrationApproved event
*/
function _approve(
string memory name,
address upkeepContract,
uint32 gasLimit,
address adminAddress,
bytes calldata checkData,
bytes32 hash
)
private
{
//call register on keeper Registry
uint256 upkeepId =
s_keeperRegistry.registerUpkeep(
upkeepContract,
gasLimit,
adminAddress,
checkData
);
// emit approve event
emit RegistrationApproved(hash, name, upkeepId);
}
//MODIFIERS
/**
* @dev Reverts if not sent from the LINK token
*/
modifier onlyLINK() {
require(msg.sender == LINK_ADDRESS, "Must use LINK token");
_;
}
/**
* @dev Reverts if the given data does not begin with the `register` function selector
* @param _data The data payload of the request
*/
modifier permittedFunctionsForLINK(
bytes memory _data
)
{
bytes4 funcSelector;
assembly {
// solhint-disable-next-line avoid-low-level-calls
funcSelector := mload(add(_data, 32))
}
require(
funcSelector == REGISTER_REQUEST_SELECTOR,
"Must use whitelisted functions"
);
_;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import './KeeperBase.sol';
import './KeeperCompatibleInterface.sol';
abstract contract KeeperCompatible is KeeperBase, KeeperCompatibleInterface {}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import '../KeeperCompatible.sol';
contract UpkeepReverter is KeeperCompatible {
function checkUpkeep(bytes calldata data)
public
view
override
cannotExecute()
returns (
bool callable,
bytes calldata executedata
)
{
require(false, "!working");
return (true, data);
}
function performUpkeep(
bytes calldata
)
external
pure
override
{
require(false, "!working");
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import '../KeeperCompatible.sol';
contract UpkeepMock is KeeperCompatible {
bool public canCheck;
bool public canPerform;
event UpkeepPerformedWith(bytes upkeepData);
function setCanCheck(bool value)
public
{
canCheck = value;
}
function setCanPerform(bool value)
public
{
canPerform = value;
}
function checkUpkeep(bytes calldata data)
external
override
cannotExecute()
returns (
bool callable,
bytes calldata executedata
)
{
bool couldCheck = canCheck;
setCanCheck(false); // test that state modifcations don't stick
return (couldCheck, data);
}
function performUpkeep(
bytes calldata data
)
external
override
{
require(canPerform, "Cannot perform");
setCanPerform(false);
emit UpkeepPerformedWith(data);
}
}
| * @notice read the minimum LINK required to send registration request/ | function getMinLINKJuels()
external
view
returns (
uint256
)
{
return s_minLINKJuels;
}
| 5,993,734 | [
1,
896,
326,
5224,
22926,
1931,
358,
1366,
7914,
590,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
9555,
10554,
46,
89,
10558,
1435,
7010,
1377,
3903,
7010,
1377,
1476,
7010,
1377,
1135,
261,
203,
1850,
2254,
5034,
203,
1377,
262,
203,
565,
288,
203,
3639,
327,
272,
67,
1154,
10554,
46,
89,
10558,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/11155111/0x43082Cd06c3747CF5968Fc0a2278749567e1396b/sources/contracts/manifold/creator-core/core/CreatorCore.sol | * @dev Set base token uri for an extension/ | function _setBaseTokenURIExtension(string calldata uri, bool identical)
internal
{
_extensionBaseURI[msg.sender] = uri;
_extensionBaseURIIdentical[msg.sender] = identical;
}
| 3,798,454 | [
1,
694,
1026,
1147,
2003,
364,
392,
2710,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
389,
542,
2171,
1345,
3098,
3625,
12,
1080,
745,
892,
2003,
16,
1426,
12529,
13,
203,
3639,
2713,
203,
565,
288,
203,
3639,
389,
6447,
2171,
3098,
63,
3576,
18,
15330,
65,
273,
2003,
31,
203,
3639,
389,
6447,
2171,
3098,
6106,
1706,
63,
3576,
18,
15330,
65,
273,
12529,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
//! A Multi-signature, daily-limited account proxy/wallet library.
//!
//! Inheritable "property" contract that enables methods to be protected by
//! requiring the acquiescence of either a single, or, crucially, each of a
//! number of, designated owners.
//!
//! Usage: use modifiers onlyowner (just own owned) or onlymanyowners(hash),
//! whereby the same hash must be provided by some number (specified in
//! constructor) of the set of owners (specified in the constructor, modifiable)
//! before the interior is executed.
//!
//! Version: Parity fork 1.0
//!
//! Copyright 2016-17 Gavin Wood and Nicolas Gotchac, Parity Technologies Ltd.
//!
//! Licensed under the Apache License, Version 2.0 (the "License");
//! you may not use this file except in compliance with the License.
//! You may obtain a copy of the License at
//!
//! http://www.apache.org/licenses/LICENSE-2.0
//!
//! Unless required by applicable law or agreed to in writing, software
//! distributed under the License is distributed on an "AS IS" BASIS,
//! WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//! See the License for the specific language governing permissions and
//! limitations under the License.
pragma solidity ^0.4.13;
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
modifier only_uninitialized {
require(m_numOwners == 0);
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function init_multiowned(address[] _owners, uint _required) only_uninitialized internal {
require(_required > 0);
require(_owners.length >= _required);
m_numOwners = _owners.length;
for (uint i = 0; i < _owners.length; ++i) {
m_owners[1 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 1 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired == 0) return;
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) public constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded == 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
}
// inheritable "property" contract that enables methods to be protected by placing a linear limit (specifiable)
// on a particular resource per calendar day. is multiowned to allow the limit to be altered. resource that method
// uses is specified in the modifier.
contract daylimit is multiowned {
// METHODS
// constructor - stores initial daily limit and records the present day's index.
function init_daylimit(uint _limit) only_uninitialized internal {
m_dailyLimit = _limit;
m_lastDay = today();
}
// (re)sets the daily limit. needs many of the owners to confirm. doesn't alter the amount already spent today.
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// INTERNAL METHODS
// checks to see if there is at least `_value` left from the daily limit today. if there is, subtracts it and
// returns true. otherwise just returns false.
function underLimit(uint _value) onlyowner internal returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
// FIELDS
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
}
// interface contract for multisig proxy contracts; see below for docs.
contract multisig {
// EVENTS
// logged events:
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
// Single transaction going out of the wallet (record who signed for it, how much, and to whom it's going).
event SingleTransact(address owner, uint value, address to, bytes data, address created);
// Multi-sig transaction going out of the wallet (record who signed for it last, the operation hash, how much, and to whom it's going).
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
// FUNCTIONS
// TODO: document
function changeOwner(address _from, address _to) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) public returns (bool o_success);
}
contract creator {
function doCreate(uint _value, bytes _code) internal returns (address o_addr) {
bool failed;
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
failed := iszero(extcodesize(o_addr))
}
require(!failed);
}
}
// usage:
// bytes32 h = Wallet(w).from(oneOwner).execute(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract WalletLibrary is multisig, multiowned, daylimit, creator {
// TYPES
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// METHODS
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function WalletLibrary() {
address[] owners;
owners.push(address(0x0));
init_wallet(owners, 1, 0);
}
function init_wallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized public {
init_daylimit(_daylimit);
init_multiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) onlyowner external returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
require(_to.call.value(_value)(_data));
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
return doCreate(_value, _code);
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) public returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
require(m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data));
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
super.clearPending();
}
// FIELDS
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
} | TYPES struct for the status of a pending operation. | contract multiowned {
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
event Revoke(address owner, bytes32 operation);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
event Confirmation(address owner, bytes32 operation);
event OwnerChanged(address oldOwner, address newOwner);
event RequirementChanged(uint newRequirement);
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
modifier only_uninitialized {
require(m_numOwners == 0);
_;
}
function init_multiowned(address[] _owners, uint _required) only_uninitialized internal {
require(_required > 0);
require(_owners.length >= _required);
m_numOwners = _owners.length;
for (uint i = 0; i < _owners.length; ++i) {
m_owners[1 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 1 + i;
}
m_required = _required;
}
function init_multiowned(address[] _owners, uint _required) only_uninitialized internal {
require(_required > 0);
require(_owners.length >= _required);
m_numOwners = _owners.length;
for (uint i = 0; i < _owners.length; ++i) {
m_owners[1 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 1 + i;
}
m_required = _required;
}
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired == 0) return;
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) public constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return false;
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
if (pending.yetNeeded == 0) {
pending.yetNeeded = m_required;
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
if (pending.yetNeeded == 1) {
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
if (pending.yetNeeded == 0) {
pending.yetNeeded = m_required;
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
if (pending.yetNeeded == 1) {
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
uint ownerIndexBit = 2**ownerIndex;
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
if (pending.yetNeeded == 0) {
pending.yetNeeded = m_required;
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
if (pending.yetNeeded == 1) {
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
if (pending.yetNeeded == 0) {
pending.yetNeeded = m_required;
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
if (pending.yetNeeded == 1) {
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
if (pending.yetNeeded == 0) {
pending.yetNeeded = m_required;
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
if (pending.yetNeeded == 1) {
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
uint constant c_maxOwners = 250;
bytes32[] m_pendingIndex;
uint public m_required;
uint public m_numOwners;
uint[256] m_owners;
mapping(uint => uint) m_ownerIndex;
mapping(bytes32 => PendingState) m_pending;
}
| 1,737,672 | [
1,
10564,
1958,
364,
326,
1267,
434,
279,
4634,
1674,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
3309,
995,
329,
288,
203,
203,
203,
203,
202,
1697,
16034,
1119,
288,
203,
202,
202,
11890,
4671,
11449,
31,
203,
202,
202,
11890,
25937,
7387,
31,
203,
202,
202,
11890,
770,
31,
203,
202,
97,
203,
203,
202,
2575,
23863,
12,
2867,
3410,
16,
1731,
1578,
1674,
1769,
203,
202,
2575,
16837,
8602,
12,
2867,
394,
5541,
1769,
203,
202,
2575,
16837,
10026,
12,
2867,
1592,
5541,
1769,
203,
203,
203,
202,
2575,
17580,
367,
12,
2867,
3410,
16,
1731,
1578,
1674,
1769,
203,
202,
2575,
16837,
5033,
12,
2867,
1592,
5541,
16,
1758,
394,
5541,
1769,
203,
202,
2575,
30813,
5033,
12,
11890,
394,
18599,
1769,
203,
203,
202,
20597,
1338,
8443,
288,
203,
202,
202,
430,
261,
291,
5541,
12,
3576,
18,
15330,
3719,
203,
1082,
202,
67,
31,
203,
202,
97,
203,
202,
20597,
1338,
9353,
995,
414,
12,
3890,
1578,
389,
7624,
13,
288,
203,
202,
202,
430,
261,
10927,
31151,
24899,
7624,
3719,
203,
1082,
202,
67,
31,
203,
202,
97,
203,
203,
202,
20597,
1338,
67,
318,
13227,
288,
203,
202,
202,
6528,
12,
81,
67,
2107,
5460,
414,
422,
374,
1769,
203,
202,
202,
67,
31,
203,
202,
97,
203,
203,
203,
202,
915,
1208,
67,
7027,
995,
329,
12,
2867,
8526,
389,
995,
414,
16,
2254,
389,
4718,
13,
1338,
67,
318,
13227,
2713,
288,
203,
202,
202,
6528,
24899,
4718,
405,
374,
1769,
203,
202,
202,
6528,
24899,
995,
414,
18,
2469,
1545,
389,
4718,
1769,
203,
202,
202,
81,
67,
2107,
5460,
2
] |
// Copyright (C) 2020 Maker Ecosystem Growth Holdings, INC.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.5.12;
interface DSPauseAbstract {
function delay() external view returns (uint256);
function plot(address, bytes32, bytes calldata, uint256) external;
function exec(address, bytes32, bytes calldata, uint256) external returns (bytes memory);
}
interface CatAbstract {
function rely(address) external;
function file(bytes32, bytes32, uint256) external;
function file(bytes32, bytes32, address) external;
}
interface FlipAbstract {
function rely(address usr) external;
function vat() external view returns (address);
function cat() external view returns (address);
function ilk() external view returns (bytes32);
function file(bytes32, uint256) external;
}
interface IlkRegistryAbstract {
function add(address) external;
}
interface GemJoinAbstract {
function vat() external view returns (address);
function ilk() external view returns (bytes32);
function gem() external view returns (address);
function dec() external view returns (uint256);
}
interface JugAbstract {
function init(bytes32) external;
function file(bytes32, bytes32, uint256) external;
}
interface MedianAbstract {
function kiss(address) external;
}
interface OsmAbstract {
function rely(address) external;
function src() external view returns (address);
function kiss(address) external;
}
interface OsmMomAbstract {
function setOsm(bytes32, address) external;
}
interface SpotAbstract {
function file(bytes32, bytes32, address) external;
function file(bytes32, bytes32, uint256) external;
function poke(bytes32) external;
}
interface VatAbstract {
function rely(address) external;
function init(bytes32) external;
function file(bytes32, uint256) external;
function file(bytes32, bytes32, uint256) external;
}
contract SpellAction {
// MAINNET ADDRESSES
//
// The contracts in this list should correspond to MCD core contracts, verify
// against the current release list at:
// https://changelog.makerdao.com/releases/mainnet/1.1.1/contracts.json
address constant MCD_VAT = 0x35D1b3F3D7966A1DFe207aa4514C12a259A0492B;
address constant MCD_CAT = 0xa5679C04fc3d9d8b0AaB1F0ab83555b301cA70Ea;
address constant MCD_JUG = 0x19c0976f590D67707E62397C87829d896Dc0f1F1;
address constant MCD_SPOT = 0x65C79fcB50Ca1594B025960e539eD7A9a6D434A3;
address constant MCD_POT = 0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7;
address constant MCD_END = 0xaB14d3CE3F733CACB76eC2AbE7d2fcb00c99F3d5;
address constant FLIPPER_MOM = 0xc4bE7F74Ee3743bDEd8E0fA218ee5cf06397f472;
address constant OSM_MOM = 0x76416A4d5190d071bfed309861527431304aA14f;
address constant ILK_REGISTRY = 0x8b4ce5DCbb01e0e1f0521cd8dCfb31B308E52c24;
// COMP-A specific addresses
address constant COMP = 0xc00e94Cb662C3520282E6f5717214004A7f26888;
address constant MCD_JOIN_COMP_A = 0xBEa7cDfB4b49EC154Ae1c0D731E4DC773A3265aA;
address constant MCD_FLIP_COMP_A = 0x524826F84cB3A19B6593370a5889A58c00554739;
address constant PIP_COMP = 0xBED0879953E633135a48a157718Aa791AC0108E4;
// LRC-A specific addresses
address constant LRC = 0xBBbbCA6A901c926F240b89EacB641d8Aec7AEafD;
address constant MCD_JOIN_LRC_A = 0x6C186404A7A238D3d6027C0299D1822c1cf5d8f1;
address constant MCD_FLIP_LRC_A = 0x7FdDc36dcdC435D8F54FDCB3748adcbBF70f3dAC;
address constant PIP_LRC = 0x9eb923339c24c40Bef2f4AF4961742AA7C23EF3a;
// LINK-A specific addresses
address constant LINK = 0x514910771AF9Ca656af840dff83E8264EcF986CA;
address constant MCD_JOIN_LINK_A = 0xdFccAf8fDbD2F4805C174f856a317765B49E4a50;
address constant MCD_FLIP_LINK_A = 0xB907EEdD63a30A3381E6D898e5815Ee8c9fd2c85;
address constant PIP_LINK = 0x9B0C694C6939b5EA9584e9b61C7815E8d97D9cC7;
// Decimals & precision
uint256 constant THOUSAND = 10 ** 3;
uint256 constant MILLION = 10 ** 6;
uint256 constant WAD = 10 ** 18;
uint256 constant RAY = 10 ** 27;
uint256 constant RAD = 10 ** 45;
// Many of the settings that change weekly rely on the rate accumulator
// described at https://docs.makerdao.com/smart-contract-modules/rates-module
// To check this yourself, use the following rate calculation (example 8%):
//
// $ bc -l <<< 'scale=27; e( l(1.01)/(60 * 60 * 24 * 365) )'
//
uint256 constant TWO_TWENTYFIVE_PERCENT_RATE = 1000000000705562181084137268;
uint256 constant THREE_TWENTYFIVE_PERCENT_RATE = 1000000001014175731521720677;
function execute() external {
// Set the global debt ceiling to 1,416,000,000
// 1,401 (current DC) + 7 (COMP-A) + 3 (LRC-A) + 5 (LINK-A)
VatAbstract(MCD_VAT).file("Line", 1416 * MILLION * RAD);
/************************************/
/*** COMP-A COLLATERAL ONBOARDING ***/
/************************************/
// Set ilk bytes32 variable
bytes32 ilk = "COMP-A";
// Sanity checks
require(GemJoinAbstract(MCD_JOIN_COMP_A).vat() == MCD_VAT, "join-vat-not-match");
require(GemJoinAbstract(MCD_JOIN_COMP_A).ilk() == ilk, "join-ilk-not-match");
require(GemJoinAbstract(MCD_JOIN_COMP_A).gem() == COMP, "join-gem-not-match");
require(GemJoinAbstract(MCD_JOIN_COMP_A).dec() == 18, "join-dec-not-match");
require(FlipAbstract(MCD_FLIP_COMP_A).vat() == MCD_VAT, "flip-vat-not-match");
require(FlipAbstract(MCD_FLIP_COMP_A).cat() == MCD_CAT, "flip-cat-not-match");
require(FlipAbstract(MCD_FLIP_COMP_A).ilk() == ilk, "flip-ilk-not-match");
// Set the COMP PIP in the Spotter
SpotAbstract(MCD_SPOT).file(ilk, "pip", PIP_COMP);
// Set the COMP-A Flipper in the Cat
CatAbstract(MCD_CAT).file(ilk, "flip", MCD_FLIP_COMP_A);
// Init COMP-A ilk in Vat & Jug
VatAbstract(MCD_VAT).init(ilk);
JugAbstract(MCD_JUG).init(ilk);
// Allow COMP-A Join to modify Vat registry
VatAbstract(MCD_VAT).rely(MCD_JOIN_COMP_A);
// Allow the COMP-A Flipper to reduce the Cat litterbox on deal()
CatAbstract(MCD_CAT).rely(MCD_FLIP_COMP_A);
// Allow Cat to kick auctions in COMP-A Flipper
FlipAbstract(MCD_FLIP_COMP_A).rely(MCD_CAT);
// Allow End to yank auctions in COMP-A Flipper
FlipAbstract(MCD_FLIP_COMP_A).rely(MCD_END);
// Allow FlipperMom to access to the COMP-A Flipper
FlipAbstract(MCD_FLIP_COMP_A).rely(FLIPPER_MOM);
// Allow OsmMom to access to the COMP Osm
OsmAbstract(PIP_COMP).rely(OSM_MOM);
// Whitelist Osm to read the Median data (only necessary if it is the first time the token is being added to an ilk)
MedianAbstract(OsmAbstract(PIP_COMP).src()).kiss(PIP_COMP);
// Whitelist Spotter to read the Osm data (only necessary if it is the first time the token is being added to an ilk)
OsmAbstract(PIP_COMP).kiss(MCD_SPOT);
// Whitelist End to read the Osm data (only necessary if it is the first time the token is being added to an ilk)
OsmAbstract(PIP_COMP).kiss(MCD_END);
// Set COMP Osm in the OsmMom for new ilk
OsmMomAbstract(OSM_MOM).setOsm(ilk, PIP_COMP);
// Set the COMP-A debt ceiling
VatAbstract(MCD_VAT).file(ilk, "line", 7 * MILLION * RAD);
// Set the COMP-A dust
VatAbstract(MCD_VAT).file(ilk, "dust", 100 * RAD);
// Set the COMP-A dunk
CatAbstract(MCD_CAT).file(ilk, "dunk", 50 * THOUSAND * RAD);
// Set the COMP-A liquidation penalty
CatAbstract(MCD_CAT).file(ilk, "chop", 113 * WAD / 100);
// Set the COMP-A stability fee
JugAbstract(MCD_JUG).file(ilk, "duty", THREE_TWENTYFIVE_PERCENT_RATE);
// Set the COMP-A percentage between bids
FlipAbstract(MCD_FLIP_COMP_A).file("beg", 103 * WAD / 100);
// Set the COMP-A time max time between bids
FlipAbstract(MCD_FLIP_COMP_A).file("ttl", 6 hours);
// Set the COMP-A max auction duration to
FlipAbstract(MCD_FLIP_COMP_A).file("tau", 6 hours);
// Set the COMP-A min collateralization ratio
SpotAbstract(MCD_SPOT).file(ilk, "mat", 175 * RAY / 100);
// Update COMP-A spot value in Vat
SpotAbstract(MCD_SPOT).poke(ilk);
// Add new ilk to the IlkRegistry
IlkRegistryAbstract(ILK_REGISTRY).add(MCD_JOIN_COMP_A);
/***********************************/
/*** LRC-A COLLATERAL ONBOARDING ***/
/***********************************/
// Set ilk bytes32 variable
ilk = "LRC-A";
// Sanity checks
require(GemJoinAbstract(MCD_JOIN_LRC_A).vat() == MCD_VAT, "join-vat-not-match");
require(GemJoinAbstract(MCD_JOIN_LRC_A).ilk() == ilk, "join-ilk-not-match");
require(GemJoinAbstract(MCD_JOIN_LRC_A).gem() == LRC, "join-gem-not-match");
require(GemJoinAbstract(MCD_JOIN_LRC_A).dec() == 18, "join-dec-not-match");
require(FlipAbstract(MCD_FLIP_LRC_A).vat() == MCD_VAT, "flip-vat-not-match");
require(FlipAbstract(MCD_FLIP_LRC_A).cat() == MCD_CAT, "flip-cat-not-match");
require(FlipAbstract(MCD_FLIP_LRC_A).ilk() == ilk, "flip-ilk-not-match");
// Set the LRC PIP in the Spotter
SpotAbstract(MCD_SPOT).file(ilk, "pip", PIP_LRC);
// Set the LRC-A Flipper in the Cat
CatAbstract(MCD_CAT).file(ilk, "flip", MCD_FLIP_LRC_A);
// Init LRC-A ilk in Vat & Jug
VatAbstract(MCD_VAT).init(ilk);
JugAbstract(MCD_JUG).init(ilk);
// Allow LRC-A Join to modify Vat registry
VatAbstract(MCD_VAT).rely(MCD_JOIN_LRC_A);
// Allow the LRC-A Flipper to reduce the Cat litterbox on deal()
CatAbstract(MCD_CAT).rely(MCD_FLIP_LRC_A);
// Allow Cat to kick auctions in LRC-A Flipper
FlipAbstract(MCD_FLIP_LRC_A).rely(MCD_CAT);
// Allow End to yank auctions in LRC-A Flipper
FlipAbstract(MCD_FLIP_LRC_A).rely(MCD_END);
// Allow FlipperMom to access to the LRC-A Flipper
FlipAbstract(MCD_FLIP_LRC_A).rely(FLIPPER_MOM);
// Allow OsmMom to access to the LRC Osm
OsmAbstract(PIP_LRC).rely(OSM_MOM);
// Whitelist Osm to read the Median data (only necessary if it is the first time the token is being added to an ilk)
MedianAbstract(OsmAbstract(PIP_LRC).src()).kiss(PIP_LRC);
// Whitelist Spotter to read the Osm data (only necessary if it is the first time the token is being added to an ilk)
OsmAbstract(PIP_LRC).kiss(MCD_SPOT);
// Whitelist End to read the Osm data (only necessary if it is the first time the token is being added to an ilk)
OsmAbstract(PIP_LRC).kiss(MCD_END);
// Set LRC Osm in the OsmMom for new ilk
OsmMomAbstract(OSM_MOM).setOsm(ilk, PIP_LRC);
// Set the LRC-A debt ceiling
VatAbstract(MCD_VAT).file(ilk, "line", 3 * MILLION * RAD);
// Set the LRC-A dust
VatAbstract(MCD_VAT).file(ilk, "dust", 100 * RAD);
// Set the LRC-A dunk
CatAbstract(MCD_CAT).file(ilk, "dunk", 50 * THOUSAND * RAD);
// Set the LRC-A liquidation penalty
CatAbstract(MCD_CAT).file(ilk, "chop", 113 * WAD / 100);
// Set the LRC-A stability fee
JugAbstract(MCD_JUG).file(ilk, "duty", THREE_TWENTYFIVE_PERCENT_RATE);
// Set the LRC-A percentage between bids
FlipAbstract(MCD_FLIP_LRC_A).file("beg", 103 * WAD / 100);
// Set the LRC-A time max time between bids
FlipAbstract(MCD_FLIP_LRC_A).file("ttl", 6 hours);
// Set the LRC-A max auction duration to
FlipAbstract(MCD_FLIP_LRC_A).file("tau", 6 hours);
// Set the LRC-A min collateralization ratio
SpotAbstract(MCD_SPOT).file(ilk, "mat", 175 * RAY / 100);
// Update LRC-A spot value in Vat
SpotAbstract(MCD_SPOT).poke(ilk);
// Add new ilk to the IlkRegistry
IlkRegistryAbstract(ILK_REGISTRY).add(MCD_JOIN_LRC_A);
/************************************/
/*** LINK-A COLLATERAL ONBOARDING ***/
/************************************/
// Set ilk bytes32 variable
ilk = "LINK-A";
// Sanity checks
require(GemJoinAbstract(MCD_JOIN_LINK_A).vat() == MCD_VAT, "join-vat-not-match");
require(GemJoinAbstract(MCD_JOIN_LINK_A).ilk() == ilk, "join-ilk-not-match");
require(GemJoinAbstract(MCD_JOIN_LINK_A).gem() == LINK, "join-gem-not-match");
require(GemJoinAbstract(MCD_JOIN_LINK_A).dec() == 18, "join-dec-not-match");
require(FlipAbstract(MCD_FLIP_LINK_A).vat() == MCD_VAT, "flip-vat-not-match");
require(FlipAbstract(MCD_FLIP_LINK_A).cat() == MCD_CAT, "flip-cat-not-match");
require(FlipAbstract(MCD_FLIP_LINK_A).ilk() == ilk, "flip-ilk-not-match");
// Set the LINK PIP in the Spotter
SpotAbstract(MCD_SPOT).file(ilk, "pip", PIP_LINK);
// Set the LINK-A Flipper in the Cat
CatAbstract(MCD_CAT).file(ilk, "flip", MCD_FLIP_LINK_A);
// Init LINK-A ilk in Vat & Jug
VatAbstract(MCD_VAT).init(ilk);
JugAbstract(MCD_JUG).init(ilk);
// Allow LINK-A Join to modify Vat registry
VatAbstract(MCD_VAT).rely(MCD_JOIN_LINK_A);
// Allow the LINK-A Flipper to reduce the Cat litterbox on deal()
CatAbstract(MCD_CAT).rely(MCD_FLIP_LINK_A);
// Allow Cat to kick auctions in LINK-A Flipper
FlipAbstract(MCD_FLIP_LINK_A).rely(MCD_CAT);
// Allow End to yank auctions in LINK-A Flipper
FlipAbstract(MCD_FLIP_LINK_A).rely(MCD_END);
// Allow FlipperMom to access to the LINK-A Flipper
FlipAbstract(MCD_FLIP_LINK_A).rely(FLIPPER_MOM);
// Allow OsmMom to access to the LINK Osm
OsmAbstract(PIP_LINK).rely(OSM_MOM);
// Whitelist Osm to read the Median data (only necessary if it is the first time the token is being added to an ilk)
MedianAbstract(OsmAbstract(PIP_LINK).src()).kiss(PIP_LINK);
// Whitelist Spotter to read the Osm data (only necessary if it is the first time the token is being added to an ilk)
OsmAbstract(PIP_LINK).kiss(MCD_SPOT);
// Whitelist End to read the Osm data (only necessary if it is the first time the token is being added to an ilk)
OsmAbstract(PIP_LINK).kiss(MCD_END);
// Set LINK Osm in the OsmMom for new ilk
OsmMomAbstract(OSM_MOM).setOsm(ilk, PIP_LINK);
// Set the LINK-A debt ceiling
VatAbstract(MCD_VAT).file(ilk, "line", 5 * MILLION * RAD);
// Set the LINK-A dust
VatAbstract(MCD_VAT).file(ilk, "dust", 100 * RAD);
// Set the LINK-A dunk
CatAbstract(MCD_CAT).file(ilk, "dunk", 50 * THOUSAND * RAD);
// Set the LINK-A liquidation penalty
CatAbstract(MCD_CAT).file(ilk, "chop", 113 * WAD / 100);
// Set the LINK-A stability fee
JugAbstract(MCD_JUG).file(ilk, "duty", TWO_TWENTYFIVE_PERCENT_RATE);
// Set the LINK-A percentage between bids
FlipAbstract(MCD_FLIP_LINK_A).file("beg", 103 * WAD / 100);
// Set the LINK-A time max time between bids
FlipAbstract(MCD_FLIP_LINK_A).file("ttl", 6 hours);
// Set the LINK-A max auction duration to
FlipAbstract(MCD_FLIP_LINK_A).file("tau", 6 hours);
// Set the LINK-A min collateralization ratio
SpotAbstract(MCD_SPOT).file(ilk, "mat", 175 * RAY / 100);
// Update LINK-A spot value in Vat
SpotAbstract(MCD_SPOT).poke(ilk);
// Add new ilk to the IlkRegistry
IlkRegistryAbstract(ILK_REGISTRY).add(MCD_JOIN_LINK_A);
}
}
contract DssSpell {
DSPauseAbstract public pause =
DSPauseAbstract(0xbE286431454714F511008713973d3B053A2d38f3);
address public action;
bytes32 public tag;
uint256 public eta;
bytes public sig;
uint256 public expiration;
bool public done;
// Provides a descriptive tag for bot consumption
// This should be modified weekly to provide a summary of the actions
// Hash: seth keccak -- "$(wget https://raw.githubusercontent.com/makerdao/community/8980cdc055642f8aa56756d39606cc55bfe7caf6/governance/votes/Executive%20vote%20-%20September%2028%2C%202020.md -q -O - 2>/dev/null)"
string constant public description =
"2020-09-28 MakerDAO Executive Spell | Hash: 0xc19a4f25cf049ac24f56e5fd042d95691de62e583f238279752db1ad516d4e99";
// MIP15: Dark Spell Mechanism
// Hash: seth keccak -- "$(wget https://raw.githubusercontent.com/makerdao/mips/eb6d36a1007ded0a5126181f5a86276ea78a91d3/MIP15/mip15.md -q -O - 2>/dev/null)"
string constant public MIP15 = "0x081b03146714fbba3d6ed78b59fef50577adb87f33d214d68639d917be794726";
// MIP12c2-SP4: LRC Collateral Onboarding
// Hash: seth keccak -- "$(wget https://raw.githubusercontent.com/makerdao/mips/eb6d36a1007ded0a5126181f5a86276ea78a91d3/MIP12/MIP12c2-Subproposals/MIP12c2-SP4.md -q -O - 2>/dev/null)"
string constant public MIP12c2SP4 = "0x43d4abcabb8838f7708ebe51ff35fd6655ba7153006906388898615ac082a87d";
// MIP12c2-SP5: COMP Collateral Onboarding
// Hash: seth keccak -- "$(wget https://raw.githubusercontent.com/makerdao/mips/eb6d36a1007ded0a5126181f5a86276ea78a91d3/MIP12/MIP12c2-Subproposals/MIP12c2-SP5.md -q -O - 2>/dev/null)"
string constant public MIP12c2SP5 = "0xdb6c5e10409435219e99b37ef1ec18f1d265246d1e4e8d2dcca14ed86513fe38";
// MIP12c2-SP6: LINK Collateral Onboarding
// Hash: seth keccak -- "$(wget https://raw.githubusercontent.com/makerdao/mips/eb6d36a1007ded0a5126181f5a86276ea78a91d3/MIP12/MIP12c2-Subproposals/MIP12c2-SP6.md -q -O - 2>/dev/null)"
string constant public MIP12c2SP6 = "0x05896bb330f113b498c2d84c9c120d7e0cd65609b064895dd2b550162211221d";
// MIP7c3-SP3: Domain Team Onboarding (Risk Domain Team)
// Hash: seth keccak -- "$(wget https://raw.githubusercontent.com/makerdao/mips/eb6d36a1007ded0a5126181f5a86276ea78a91d3/MIP7/MIP7c3-Subproposals/MIP7c3-SP3.md -q -O - 2>/dev/null)"
string constant public MIP7c3SP3 = "0x75dff1d98dc14ddc85c4325fb75ce14f06857f5f09b0e321df91f4416f29ba7c";
// MIP7c3-SP4: Subproposal Template for Smart Contracts Domain Team Onboarding
// Hash: seth keccak -- "$(wget https://raw.githubusercontent.com/makerdao/mips/eb6d36a1007ded0a5126181f5a86276ea78a91d3/MIP7/MIP7c3-Subproposals/MIP7c3-SP4.md -q -O - 2>/dev/null)"
string constant public MIP7c3SP4 = "0x6ee0230b3ec6f25bb4c59b295ce8650db2400919fe6c4aae2bf1255106c621e4";
// MIP13c3-SP2: Declaration of Intent - Dai Flash Mint Module
// Hash: seth keccak -- "$(wget https://raw.githubusercontent.com/makerdao/mips/eb6d36a1007ded0a5126181f5a86276ea78a91d3/MIP13/MIP13c3-Subproposals/MIP13c3-SP2.md -q -O - 2>/dev/null)"
string constant public MIP13c3SP2 = "0x6e2a266ed710c4a6999c91833d04e195f3bcbc29cff7bf252cb112241400cc43";
constructor() public {
sig = abi.encodeWithSignature("execute()");
action = address(new SpellAction());
bytes32 _tag;
address _action = action;
assembly { _tag := extcodehash(_action) }
tag = _tag;
expiration = now + 4 days + 2 hours;
}
modifier officeHours {
uint day = (now / 1 days + 3) % 7;
require(day < 5, "Can only be cast on a weekday");
uint hour = now / 1 hours % 24;
require(hour >= 14 && hour < 21, "Outside office hours");
_;
}
function schedule() public {
require(now <= expiration, "This contract has expired");
require(eta == 0, "This spell has already been scheduled");
eta = now + DSPauseAbstract(pause).delay();
pause.plot(action, tag, sig, eta);
}
function cast() public officeHours {
require(!done, "spell-already-cast");
done = true;
pause.exec(action, tag, sig, eta);
}
} | Set the global debt ceiling to 1,416,000,000 1,401 (current DC) + 7 (COMP-A) + 3 (LRC-A) + 5 (LINK-A) Set ilk bytes32 variable Sanity checks Set the COMP PIP in the Spotter Set the COMP-A Flipper in the Cat Init COMP-A ilk in Vat & Jug Allow COMP-A Join to modify Vat registry Allow the COMP-A Flipper to reduce the Cat litterbox on deal() Allow Cat to kick auctions in COMP-A Flipper Allow End to yank auctions in COMP-A Flipper Allow FlipperMom to access to the COMP-A Flipper Allow OsmMom to access to the COMP Osm Whitelist Osm to read the Median data (only necessary if it is the first time the token is being added to an ilk) Whitelist Spotter to read the Osm data (only necessary if it is the first time the token is being added to an ilk) Whitelist End to read the Osm data (only necessary if it is the first time the token is being added to an ilk) Set COMP Osm in the OsmMom for new ilk Set the COMP-A debt ceiling Set the COMP-A dust Set the COMP-A dunk Set the COMP-A liquidation penalty Set the COMP-A stability fee Set the COMP-A percentage between bids Set the COMP-A time max time between bids Set the COMP-A max auction duration to Set the COMP-A min collateralization ratio Update COMP-A spot value in Vat Add new ilk to the IlkRegistry Set ilk bytes32 variable Sanity checks Set the LRC PIP in the Spotter Set the LRC-A Flipper in the Cat Init LRC-A ilk in Vat & Jug Allow LRC-A Join to modify Vat registry Allow the LRC-A Flipper to reduce the Cat litterbox on deal() Allow Cat to kick auctions in LRC-A Flipper Allow End to yank auctions in LRC-A Flipper Allow FlipperMom to access to the LRC-A Flipper Allow OsmMom to access to the LRC Osm Whitelist Osm to read the Median data (only necessary if it is the first time the token is being added to an ilk) Whitelist Spotter to read the Osm data (only necessary if it is the first time the token is being added to an ilk) Whitelist End to read the Osm data (only necessary if it is the first time the token is being added to an ilk) Set LRC Osm in the OsmMom for new ilk Set the LRC-A debt ceiling Set the LRC-A dust Set the LRC-A dunk Set the LRC-A liquidation penalty Set the LRC-A stability fee Set the LRC-A percentage between bids Set the LRC-A time max time between bids Set the LRC-A max auction duration to Set the LRC-A min collateralization ratio Update LRC-A spot value in Vat Add new ilk to the IlkRegistry Set ilk bytes32 variable Sanity checks Set the LINK PIP in the Spotter Set the LINK-A Flipper in the Cat Init LINK-A ilk in Vat & Jug Allow LINK-A Join to modify Vat registry Allow the LINK-A Flipper to reduce the Cat litterbox on deal() Allow Cat to kick auctions in LINK-A Flipper Allow End to yank auctions in LINK-A Flipper Allow FlipperMom to access to the LINK-A Flipper Allow OsmMom to access to the LINK Osm Whitelist Osm to read the Median data (only necessary if it is the first time the token is being added to an ilk) Whitelist Spotter to read the Osm data (only necessary if it is the first time the token is being added to an ilk) Whitelist End to read the Osm data (only necessary if it is the first time the token is being added to an ilk) Set LINK Osm in the OsmMom for new ilk Set the LINK-A debt ceiling Set the LINK-A dust Set the LINK-A dunk Set the LINK-A liquidation penalty Set the LINK-A stability fee Set the LINK-A percentage between bids Set the LINK-A time max time between bids Set the LINK-A max auction duration to Set the LINK-A min collateralization ratio Update LINK-A spot value in Vat Add new ilk to the IlkRegistry | function execute() external {
VatAbstract(MCD_VAT).file("Line", 1416 * MILLION * RAD);
bytes32 ilk = "COMP-A";
require(GemJoinAbstract(MCD_JOIN_COMP_A).vat() == MCD_VAT, "join-vat-not-match");
require(GemJoinAbstract(MCD_JOIN_COMP_A).ilk() == ilk, "join-ilk-not-match");
require(GemJoinAbstract(MCD_JOIN_COMP_A).gem() == COMP, "join-gem-not-match");
require(GemJoinAbstract(MCD_JOIN_COMP_A).dec() == 18, "join-dec-not-match");
require(FlipAbstract(MCD_FLIP_COMP_A).vat() == MCD_VAT, "flip-vat-not-match");
require(FlipAbstract(MCD_FLIP_COMP_A).cat() == MCD_CAT, "flip-cat-not-match");
require(FlipAbstract(MCD_FLIP_COMP_A).ilk() == ilk, "flip-ilk-not-match");
SpotAbstract(MCD_SPOT).file(ilk, "pip", PIP_COMP);
CatAbstract(MCD_CAT).file(ilk, "flip", MCD_FLIP_COMP_A);
VatAbstract(MCD_VAT).init(ilk);
JugAbstract(MCD_JUG).init(ilk);
VatAbstract(MCD_VAT).rely(MCD_JOIN_COMP_A);
CatAbstract(MCD_CAT).rely(MCD_FLIP_COMP_A);
FlipAbstract(MCD_FLIP_COMP_A).rely(MCD_CAT);
FlipAbstract(MCD_FLIP_COMP_A).rely(MCD_END);
FlipAbstract(MCD_FLIP_COMP_A).rely(FLIPPER_MOM);
OsmAbstract(PIP_COMP).rely(OSM_MOM);
MedianAbstract(OsmAbstract(PIP_COMP).src()).kiss(PIP_COMP);
OsmAbstract(PIP_COMP).kiss(MCD_SPOT);
OsmAbstract(PIP_COMP).kiss(MCD_END);
OsmMomAbstract(OSM_MOM).setOsm(ilk, PIP_COMP);
VatAbstract(MCD_VAT).file(ilk, "line", 7 * MILLION * RAD);
VatAbstract(MCD_VAT).file(ilk, "dust", 100 * RAD);
CatAbstract(MCD_CAT).file(ilk, "dunk", 50 * THOUSAND * RAD);
CatAbstract(MCD_CAT).file(ilk, "chop", 113 * WAD / 100);
JugAbstract(MCD_JUG).file(ilk, "duty", THREE_TWENTYFIVE_PERCENT_RATE);
FlipAbstract(MCD_FLIP_COMP_A).file("beg", 103 * WAD / 100);
FlipAbstract(MCD_FLIP_COMP_A).file("ttl", 6 hours);
FlipAbstract(MCD_FLIP_COMP_A).file("tau", 6 hours);
SpotAbstract(MCD_SPOT).file(ilk, "mat", 175 * RAY / 100);
SpotAbstract(MCD_SPOT).poke(ilk);
IlkRegistryAbstract(ILK_REGISTRY).add(MCD_JOIN_COMP_A);
ilk = "LRC-A";
require(GemJoinAbstract(MCD_JOIN_LRC_A).vat() == MCD_VAT, "join-vat-not-match");
require(GemJoinAbstract(MCD_JOIN_LRC_A).ilk() == ilk, "join-ilk-not-match");
require(GemJoinAbstract(MCD_JOIN_LRC_A).gem() == LRC, "join-gem-not-match");
require(GemJoinAbstract(MCD_JOIN_LRC_A).dec() == 18, "join-dec-not-match");
require(FlipAbstract(MCD_FLIP_LRC_A).vat() == MCD_VAT, "flip-vat-not-match");
require(FlipAbstract(MCD_FLIP_LRC_A).cat() == MCD_CAT, "flip-cat-not-match");
require(FlipAbstract(MCD_FLIP_LRC_A).ilk() == ilk, "flip-ilk-not-match");
SpotAbstract(MCD_SPOT).file(ilk, "pip", PIP_LRC);
CatAbstract(MCD_CAT).file(ilk, "flip", MCD_FLIP_LRC_A);
VatAbstract(MCD_VAT).init(ilk);
JugAbstract(MCD_JUG).init(ilk);
VatAbstract(MCD_VAT).rely(MCD_JOIN_LRC_A);
CatAbstract(MCD_CAT).rely(MCD_FLIP_LRC_A);
FlipAbstract(MCD_FLIP_LRC_A).rely(MCD_CAT);
FlipAbstract(MCD_FLIP_LRC_A).rely(MCD_END);
FlipAbstract(MCD_FLIP_LRC_A).rely(FLIPPER_MOM);
OsmAbstract(PIP_LRC).rely(OSM_MOM);
MedianAbstract(OsmAbstract(PIP_LRC).src()).kiss(PIP_LRC);
OsmAbstract(PIP_LRC).kiss(MCD_SPOT);
OsmAbstract(PIP_LRC).kiss(MCD_END);
OsmMomAbstract(OSM_MOM).setOsm(ilk, PIP_LRC);
VatAbstract(MCD_VAT).file(ilk, "line", 3 * MILLION * RAD);
VatAbstract(MCD_VAT).file(ilk, "dust", 100 * RAD);
CatAbstract(MCD_CAT).file(ilk, "dunk", 50 * THOUSAND * RAD);
CatAbstract(MCD_CAT).file(ilk, "chop", 113 * WAD / 100);
JugAbstract(MCD_JUG).file(ilk, "duty", THREE_TWENTYFIVE_PERCENT_RATE);
FlipAbstract(MCD_FLIP_LRC_A).file("beg", 103 * WAD / 100);
FlipAbstract(MCD_FLIP_LRC_A).file("ttl", 6 hours);
FlipAbstract(MCD_FLIP_LRC_A).file("tau", 6 hours);
SpotAbstract(MCD_SPOT).file(ilk, "mat", 175 * RAY / 100);
SpotAbstract(MCD_SPOT).poke(ilk);
IlkRegistryAbstract(ILK_REGISTRY).add(MCD_JOIN_LRC_A);
ilk = "LINK-A";
require(GemJoinAbstract(MCD_JOIN_LINK_A).vat() == MCD_VAT, "join-vat-not-match");
require(GemJoinAbstract(MCD_JOIN_LINK_A).ilk() == ilk, "join-ilk-not-match");
require(GemJoinAbstract(MCD_JOIN_LINK_A).gem() == LINK, "join-gem-not-match");
require(GemJoinAbstract(MCD_JOIN_LINK_A).dec() == 18, "join-dec-not-match");
require(FlipAbstract(MCD_FLIP_LINK_A).vat() == MCD_VAT, "flip-vat-not-match");
require(FlipAbstract(MCD_FLIP_LINK_A).cat() == MCD_CAT, "flip-cat-not-match");
require(FlipAbstract(MCD_FLIP_LINK_A).ilk() == ilk, "flip-ilk-not-match");
SpotAbstract(MCD_SPOT).file(ilk, "pip", PIP_LINK);
CatAbstract(MCD_CAT).file(ilk, "flip", MCD_FLIP_LINK_A);
VatAbstract(MCD_VAT).init(ilk);
JugAbstract(MCD_JUG).init(ilk);
VatAbstract(MCD_VAT).rely(MCD_JOIN_LINK_A);
CatAbstract(MCD_CAT).rely(MCD_FLIP_LINK_A);
FlipAbstract(MCD_FLIP_LINK_A).rely(MCD_CAT);
FlipAbstract(MCD_FLIP_LINK_A).rely(MCD_END);
FlipAbstract(MCD_FLIP_LINK_A).rely(FLIPPER_MOM);
OsmAbstract(PIP_LINK).rely(OSM_MOM);
MedianAbstract(OsmAbstract(PIP_LINK).src()).kiss(PIP_LINK);
OsmAbstract(PIP_LINK).kiss(MCD_SPOT);
OsmAbstract(PIP_LINK).kiss(MCD_END);
OsmMomAbstract(OSM_MOM).setOsm(ilk, PIP_LINK);
VatAbstract(MCD_VAT).file(ilk, "line", 5 * MILLION * RAD);
VatAbstract(MCD_VAT).file(ilk, "dust", 100 * RAD);
CatAbstract(MCD_CAT).file(ilk, "dunk", 50 * THOUSAND * RAD);
CatAbstract(MCD_CAT).file(ilk, "chop", 113 * WAD / 100);
JugAbstract(MCD_JUG).file(ilk, "duty", TWO_TWENTYFIVE_PERCENT_RATE);
FlipAbstract(MCD_FLIP_LINK_A).file("beg", 103 * WAD / 100);
FlipAbstract(MCD_FLIP_LINK_A).file("ttl", 6 hours);
FlipAbstract(MCD_FLIP_LINK_A).file("tau", 6 hours);
SpotAbstract(MCD_SPOT).file(ilk, "mat", 175 * RAY / 100);
SpotAbstract(MCD_SPOT).poke(ilk);
IlkRegistryAbstract(ILK_REGISTRY).add(MCD_JOIN_LINK_A);
}
| 6,984,733 | [
1,
694,
326,
2552,
18202,
88,
5898,
4973,
358,
404,
16,
24,
2313,
16,
3784,
16,
3784,
404,
16,
27002,
261,
2972,
21533,
13,
397,
2371,
261,
10057,
17,
37,
13,
397,
890,
261,
48,
11529,
17,
37,
13,
397,
1381,
261,
10554,
17,
37,
13,
1000,
14254,
79,
1731,
1578,
2190,
23123,
4271,
1000,
326,
13846,
453,
2579,
316,
326,
26523,
387,
1000,
326,
13846,
17,
37,
478,
3169,
457,
316,
326,
385,
270,
4378,
13846,
17,
37,
14254,
79,
316,
25299,
473,
804,
637,
7852,
13846,
17,
37,
4214,
358,
5612,
25299,
4023,
7852,
326,
13846,
17,
37,
478,
3169,
457,
358,
5459,
326,
385,
270,
328,
6132,
2147,
603,
10490,
1435,
7852,
385,
270,
358,
23228,
279,
4062,
87,
316,
13846,
17,
37,
478,
3169,
457,
7852,
4403,
358,
677,
2304,
279,
4062,
87,
316,
13846,
17,
37,
478,
3169,
457,
7852,
478,
3169,
457,
49,
2
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
] | [
1,
565,
445,
1836,
1435,
3903,
288,
203,
3639,
25299,
7469,
12,
49,
10160,
67,
58,
789,
2934,
768,
2932,
1670,
3113,
5045,
2313,
380,
490,
15125,
1146,
380,
534,
1880,
1769,
203,
203,
3639,
1731,
1578,
14254,
79,
273,
315,
10057,
17,
37,
14432,
203,
203,
3639,
2583,
12,
43,
351,
4572,
7469,
12,
49,
10160,
67,
18800,
67,
10057,
67,
37,
2934,
25012,
1435,
422,
490,
10160,
67,
58,
789,
16,
315,
5701,
17,
25012,
17,
902,
17,
1916,
8863,
203,
3639,
2583,
12,
43,
351,
4572,
7469,
12,
49,
10160,
67,
18800,
67,
10057,
67,
37,
2934,
330,
79,
1435,
422,
14254,
79,
16,
377,
315,
5701,
17,
330,
79,
17,
902,
17,
1916,
8863,
203,
3639,
2583,
12,
43,
351,
4572,
7469,
12,
49,
10160,
67,
18800,
67,
10057,
67,
37,
2934,
23465,
1435,
422,
13846,
16,
565,
315,
5701,
17,
23465,
17,
902,
17,
1916,
8863,
203,
3639,
2583,
12,
43,
351,
4572,
7469,
12,
49,
10160,
67,
18800,
67,
10057,
67,
37,
2934,
4924,
1435,
422,
6549,
16,
1377,
315,
5701,
17,
4924,
17,
902,
17,
1916,
8863,
203,
3639,
2583,
12,
28535,
7469,
12,
49,
10160,
67,
42,
2053,
52,
67,
10057,
67,
37,
2934,
25012,
1435,
422,
490,
10160,
67,
58,
789,
16,
565,
315,
12357,
17,
25012,
17,
902,
17,
1916,
8863,
203,
3639,
2583,
12,
28535,
7469,
12,
49,
10160,
67,
42,
2053,
52,
67,
10057,
67,
37,
2934,
2574,
1435,
422,
490,
10160,
67,
14130,
16,
565,
315,
12357,
17,
2574,
17,
902,
17,
2
] |
./partial_match/1/0x6b2C42D2Aa4CB2D859CF7a88546dB12ae294F303/sources/contracts/interfaces/IERC20.sol | Emitted when the allowance of a spender for an owner is set by a call to approve. Value is the new allowance Emitted when value tokens are moved from one account (from) to another (to). Note that value may be zero Returns the amount of tokens in existence Returns the amount of tokens owned by account Returns the decimals of tokens 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 Sets amount as the allowance of spender over the callerโs tokens Returns a boolean value indicating whether the operation succeeded Emits an Approval event. Moves amount tokens from the callerโs account to recipient Returns a boolean value indicating whether the operation succeeded Emits a Transfer event. 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 | interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transfer(address recipient, uint amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint amount
) external returns (bool);
pragma solidity 0.6.12;
}
| 2,714,581 | [
1,
1514,
11541,
1347,
326,
1699,
1359,
434,
279,
17571,
264,
364,
392,
3410,
353,
444,
635,
279,
745,
358,
6617,
537,
18,
1445,
353,
326,
394,
1699,
1359,
512,
7948,
1347,
460,
2430,
854,
10456,
628,
1245,
2236,
261,
2080,
13,
358,
4042,
261,
869,
2934,
3609,
716,
460,
2026,
506,
3634,
2860,
326,
3844,
434,
2430,
316,
15782,
2860,
326,
3844,
434,
2430,
16199,
635,
2236,
2860,
326,
15105,
434,
2430,
2860,
326,
4463,
1300,
434,
2430,
716,
17571,
264,
903,
506,
2935,
358,
17571,
603,
12433,
6186,
434,
3410,
3059,
7412,
1265,
18,
1220,
353,
3634,
635,
805,
1220,
460,
3478,
1347,
6617,
537,
578,
7412,
1265,
854,
2566,
11511,
3844,
487,
326,
1699,
1359,
434,
17571,
264,
1879,
326,
4894,
163,
227,
252,
87,
2430,
2860,
279,
1250,
460,
11193,
2856,
326,
1674,
15784,
7377,
1282,
392,
1716,
685,
1125,
871,
18,
490,
10829,
3844,
2
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
] | [
1,
5831,
467,
654,
39,
3462,
288,
203,
565,
871,
1716,
685,
1125,
12,
2867,
8808,
3410,
16,
1758,
8808,
17571,
264,
16,
2254,
460,
1769,
203,
203,
565,
871,
12279,
12,
2867,
8808,
628,
16,
1758,
8808,
358,
16,
2254,
460,
1769,
203,
203,
565,
445,
2078,
3088,
1283,
1435,
3903,
1476,
1135,
261,
11890,
1769,
203,
203,
565,
445,
11013,
951,
12,
2867,
2236,
13,
3903,
1476,
1135,
261,
11890,
1769,
203,
203,
565,
445,
15105,
1435,
3903,
1476,
1135,
261,
11890,
28,
1769,
203,
203,
565,
445,
3273,
1435,
3903,
1476,
1135,
261,
1080,
3778,
1769,
203,
203,
565,
445,
1699,
1359,
12,
2867,
3410,
16,
1758,
17571,
264,
13,
3903,
1476,
1135,
261,
11890,
1769,
203,
203,
565,
445,
6617,
537,
12,
2867,
17571,
264,
16,
2254,
3844,
13,
3903,
1135,
261,
6430,
1769,
203,
203,
565,
445,
7412,
12,
2867,
8027,
16,
2254,
3844,
13,
3903,
1135,
261,
6430,
1769,
203,
203,
565,
445,
7412,
1265,
12,
203,
3639,
1758,
5793,
16,
203,
3639,
1758,
8027,
16,
203,
3639,
2254,
3844,
203,
565,
262,
3903,
1135,
261,
6430,
1769,
203,
683,
9454,
18035,
560,
374,
18,
26,
18,
2138,
31,
203,
203,
203,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/11155111/0x3A82D3111aB5faF39d847D46023d9090261A658F/sources/contracts/contracts/tokens/AGOLDTestToken.sol | * @title AGOLDToken - Gold token @dev Contract containing init logic for upgradable token representing gold equivalent/ | contract AGOLDTestToken is ERC20 {
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
constructor() ERC20("AgAu Gold", "AGLD") {
}
function mint(address beneficiary, uint amount) external {
_mint(beneficiary, amount);
}
}
| 3,814,260 | [
1,
1781,
11846,
1345,
300,
611,
1673,
1147,
225,
13456,
4191,
1208,
4058,
364,
731,
9974,
429,
1147,
5123,
20465,
7680,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
432,
43,
11846,
4709,
1345,
353,
4232,
39,
3462,
288,
203,
203,
5666,
288,
654,
39,
3462,
97,
628,
8787,
3190,
94,
881,
84,
292,
267,
19,
16351,
87,
19,
2316,
19,
654,
39,
3462,
19,
654,
39,
3462,
18,
18281,
14432,
203,
565,
3885,
1435,
4232,
39,
3462,
2932,
2577,
37,
89,
611,
1673,
3113,
315,
1781,
12069,
7923,
288,
203,
565,
289,
203,
203,
565,
445,
312,
474,
12,
2867,
27641,
74,
14463,
814,
16,
2254,
3844,
13,
3903,
288,
203,
3639,
389,
81,
474,
12,
70,
4009,
74,
14463,
814,
16,
3844,
1769,
203,
565,
289,
203,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/80001/0x4436485155E81382b8DE76b29d4f79C52C27AAF7/sources/contracts/dao/ERC1155Dao.sol | @notice operation cannot be performed because a borrower is already active. Signature : `0x3ecb46e3` | error BorrowerActive();
| 5,682,193 | [
1,
7624,
2780,
506,
9591,
2724,
279,
29759,
264,
353,
1818,
2695,
18,
9249,
294,
1375,
20,
92,
23,
557,
70,
8749,
73,
23,
68,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
555,
605,
15318,
264,
3896,
5621,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
//Address: 0x13c2fab6354d3790d8ece4f0f1a3280b4a25ad96
//Contract name: PhiToken
//Balance: 0 Ether
//Verification Date: 2/28/2018
//Transacion Count: 42500
// CODE STARTS HERE
pragma solidity ^0.4.18;
/*
* Contract that is working with ERC223 tokens
* https://github.com/ethereum/EIPs/issues/223
*/
/// @title ERC223ReceivingContract - Standard contract implementation for compatibility with ERC223 tokens.
contract ERC223ReceivingContract {
/// @dev Function that is called when a user or another contract wants to transfer funds.
/// @param _from Transaction initiator, analogue of msg.sender
/// @param _value Number of tokens to transfer.
/// @param _data Data containig a function signature and/or parameters
function tokenFallback(address _from, uint256 _value, bytes _data) public;
}
/// @title Base Token contract - Functions to be implemented by token contracts.
contract Token {
/*
* Implements ERC 20 standard.
* https://github.com/ethereum/EIPs/blob/f90864a3d2b2b45c4decf95efd26b3f0c276051a/EIPS/eip-20-token-standard.md
* https://github.com/ethereum/EIPs/issues/20
*
* Added support for the ERC 223 "tokenFallback" method in a "transfer" function with a payload.
* https://github.com/ethereum/EIPs/issues/223
*/
/*
* ERC 20
*/
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function burn(uint num) public;
/*
* ERC 223
*/
function transfer(address _to, uint256 _value, bytes _data) public returns (bool success);
/*
* Events
*/
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed _burner, uint _value);
// There is no ERC223 compatible Transfer event, with `_data` included.
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/// @title PHI ERC223 Token with burn functionality
contract PhiToken is Token {
/*
* Terminology:
* 1 token unit = PHI
* 1 token = PHI = sphi * multiplier
* multiplier set from token's number of decimals (i.e. 10 ** decimals)
*/
/*
* Section 1
* - Variables
*/
/// Token metadata
string constant public name = "PHI Token";
string constant public symbol = "PHI";
uint8 constant public decimals = 18;
using SafeMath for uint;
uint constant multiplier = 10 ** uint(decimals);
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
/*
* This is a slight change to the ERC20 base standard.
* function totalSupply() constant returns (uint256 supply);
* is replaced with:
* uint256 public totalSupply;
* This automatically creates a getter function for the totalSupply.
* This is moved to the base contract since public getter functions are not
* currently recognised as an implementation of the matching abstract
* function by the compiler.
*
* Hardcoded total supply (in sphi), it can be decreased only by burning tokens
*/
uint256 public totalSupply = 24157817 * multiplier;
/// Keep track of assigned tokens at deploy
bool initialTokensAssigned = false;
/// Store pre-ico and ico address
address public PRE_ICO_ADDR;
address public ICO_ADDR;
/// Where tokens for team will be sent, used also for function-auth
address public WALLET_ADDR;
/// How long the tokens should be locked for transfers
uint public lockTime;
/*
* Section 2
* - modifiers
*/
/// Do not allow transfers if lockTime is active, allow only
/// pre-ico and ico if it is (to distribute tokens)
modifier onlyIfLockTimePassed () {
require(now > lockTime || (msg.sender == PRE_ICO_ADDR || msg.sender == ICO_ADDR));
_;
}
/*
* Section 3
* - Events
*/
event Deployed(uint indexed _total_supply);
/*
* Public functions
*/
/// @dev Contract constructor function, assigns tokens to ico, pre-ico,
/// wallet address and pre sale investors.
/// @param ico_address Address of the ico contract.
/// @param pre_ico_address Address of the pre-ico contract.
/// @param wallet_address Address of tokens to be sent to the PHI team.
/// @param _lockTime Epoch Timestamp describing how long the tokens should be
/// locked for transfers.
function PhiToken(
address ico_address,
address pre_ico_address,
address wallet_address,
uint _lockTime)
public
{
// Check destination address
require(ico_address != 0x0);
require(pre_ico_address != 0x0);
require(wallet_address != 0x0);
require(ico_address != pre_ico_address && wallet_address != ico_address);
require(initialTokensAssigned == false);
// _lockTime should be in the future
require(_lockTime > now);
lockTime = _lockTime;
WALLET_ADDR = wallet_address;
// Check total supply
require(totalSupply > multiplier);
// tokens to be assigned to pre-ico, ico and wallet address
uint initAssign = 0;
// to be sold in the ico
initAssign += assignTokens(ico_address, 7881196 * multiplier);
ICO_ADDR = ico_address;
// to be sold in the pre-ico
initAssign += assignTokens(pre_ico_address, 3524578 * multiplier);
PRE_ICO_ADDR = pre_ico_address;
// Reserved for the team, airdrop, marketing, business etc..
initAssign += assignTokens(wallet_address, 9227465 * multiplier);
// Pre sale allocations
uint presaleTokens = 0;
presaleTokens += assignTokens(address(0x72B16DC0e5f85aA4BBFcE81687CCc9D6871C2965), 230387 * multiplier);
presaleTokens += assignTokens(address(0x7270cC02d88Ea63FC26384f5d08e14EE87E75154), 132162 * multiplier);
presaleTokens += assignTokens(address(0x25F92f21222969BB0b1f14f19FBa770D30Ff678f), 132162 * multiplier);
presaleTokens += assignTokens(address(0xAc99C59D3353a34531Fae217Ba77139BBe4eDBb3), 443334 * multiplier);
presaleTokens += assignTokens(address(0xbe41D37eB2d2859143B9f1D29c7BC6d7e59174Da), 970826500000000000000000); // 970826.5 PHI
presaleTokens += assignTokens(address(0x63e9FA0e43Fcc7C702ed5997AfB8E215C5beE3c9), 970826500000000000000000); // 970826.5 PHI
presaleTokens += assignTokens(address(0x95c67812c5C41733419aC3b1916d2F282E7A15A4), 396486 * multiplier);
presaleTokens += assignTokens(address(0x1f5d30BB328498fF6E09b717EC22A9046C41C257), 20144 * multiplier);
presaleTokens += assignTokens(address(0x0a1ac564e95dAEDF8d454a3593b75CCdd474fc42), 19815 * multiplier);
presaleTokens += assignTokens(address(0x0C5448D5bC4C40b4d2b2c1D7E58E0541698d3e6E), 19815 * multiplier);
presaleTokens += assignTokens(address(0xFAe11D521538F067cE0B13B6f8C929cdEA934D07), 75279 * multiplier);
presaleTokens += assignTokens(address(0xEE51304603887fFF15c6d12165C6d96ff0f0c85b), 45949 * multiplier);
presaleTokens += assignTokens(address(0xd7Bab04C944faAFa232d6EBFE4f60FF8C4e9815F), 6127 * multiplier);
presaleTokens += assignTokens(address(0x603f39C81560019c8360F33bA45Bc1E4CAECb33e), 45949 * multiplier);
presaleTokens += assignTokens(address(0xBB5128f1093D1aa85F6d7D0cC20b8415E0104eDD), 15316 * multiplier);
initialTokensAssigned = true;
Deployed(totalSupply);
assert(presaleTokens == 3524578 * multiplier);
assert(totalSupply == (initAssign.add(presaleTokens)));
}
/// @dev Helper function to assign tokens (team, pre-sale, ico, pre-ico etc..).
/// @notice It will be automatically called on deploy.
/// @param addr Receiver of the tokens.
/// @param amount Tokens (in sphi).
/// @return Tokens assigned
function assignTokens (address addr, uint amount) internal returns (uint) {
require(addr != 0x0);
require(initialTokensAssigned == false);
balances[addr] = amount;
Transfer(0x0, addr, balances[addr]);
return balances[addr];
}
/// @notice Allows `msg.sender` to simply destroy `_value` token units (sphi). This means the total
/// token supply will decrease.
/// @dev Allows to destroy token units (sphi).
/// @param _value Number of token units (sphi) to burn.
function burn(uint256 _value) public onlyIfLockTimePassed {
require(_value > 0);
require(balances[msg.sender] >= _value);
require(totalSupply >= _value);
uint pre_balance = balances[msg.sender];
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
Transfer(burner, 0x0, _value);
assert(balances[burner] == pre_balance.sub(_value));
}
/*
* Token functions
*/
/// @notice Send `_value` tokens to `_to` from `msg.sender`.
/// @dev Transfers sender's tokens to a given address. Returns success.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
/// @return Returns success of function call.
function transfer(address _to, uint256 _value) public onlyIfLockTimePassed returns (bool) {
require(_to != 0x0);
require(_to != address(this));
require(balances[msg.sender] >= _value);
require(balances[_to].add(_value) >= balances[_to]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
/// @notice Send `_value` tokens to `_to` from `msg.sender` and trigger
/// tokenFallback if sender is a contract.
/// @dev Function that is called when a user or another contract wants to transfer funds.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
/// @param _data Data to be sent to tokenFallback
/// @return Returns success of function call.
function transfer(
address _to,
uint256 _value,
bytes _data)
public
onlyIfLockTimePassed
returns (bool)
{
require(transfer(_to, _value));
uint codeLength;
assembly {
// Retrieve the size of the code on target address, this needs assembly.
codeLength := extcodesize(_to)
}
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
return true;
}
/// @notice Transfer `_value` tokens from `_from` to `_to` if `msg.sender` is allowed.
/// @dev Allows for an approved third party to transfer tokens from one
/// address to another. Returns success.
/// @param _from Address from where tokens are withdrawn.
/// @param _to Address to where tokens are sent.
/// @param _value Number of tokens to transfer.
/// @return Returns success of function call.
function transferFrom(address _from, address _to, uint256 _value)
public
onlyIfLockTimePassed
returns (bool)
{
require(_from != 0x0);
require(_to != 0x0);
require(_to != address(this));
require(balances[_from] >= _value);
require(allowed[_from][msg.sender] >= _value);
require(balances[_to].add(_value) >= balances[_to]);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/// @notice Allows `_spender` to transfer `_value` tokens from `msg.sender` to any address.
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
/// @return Returns success of function call.
function approve(address _spender, uint256 _value) public onlyIfLockTimePassed returns (bool) {
require(_spender != 0x0);
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(_value == 0 || allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/*
* Read functions
*/
/// @dev Returns number of allowed tokens that a spender can transfer on
/// behalf of a token owner.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
/// @return Returns remaining allowance for spender.
function allowance(address _owner, address _spender)
constant
public
returns (uint256)
{
return allowed[_owner][_spender];
}
/// @dev Returns number of tokens owned by the given address.
/// @param _owner Address of token owner.
/// @return Returns balance of owner.
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
}
| @title PHI ERC223 Token with burn functionality | contract PhiToken is Token {
string constant public name = "PHI Token";
string constant public symbol = "PHI";
uint8 constant public decimals = 18;
using SafeMath for uint;
uint constant multiplier = 10 ** uint(decimals);
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply = 24157817 * multiplier;
bool initialTokensAssigned = false;
address public PRE_ICO_ADDR;
address public ICO_ADDR;
address public WALLET_ADDR;
uint public lockTime;
modifier onlyIfLockTimePassed () {
require(now > lockTime || (msg.sender == PRE_ICO_ADDR || msg.sender == ICO_ADDR));
_;
}
event Deployed(uint indexed _total_supply);
function PhiToken(
address ico_address,
address pre_ico_address,
address wallet_address,
uint _lockTime)
public
{
require(ico_address != 0x0);
require(pre_ico_address != 0x0);
require(wallet_address != 0x0);
require(ico_address != pre_ico_address && wallet_address != ico_address);
require(initialTokensAssigned == false);
require(_lockTime > now);
lockTime = _lockTime;
WALLET_ADDR = wallet_address;
require(totalSupply > multiplier);
uint initAssign = 0;
initAssign += assignTokens(ico_address, 7881196 * multiplier);
ICO_ADDR = ico_address;
initAssign += assignTokens(pre_ico_address, 3524578 * multiplier);
PRE_ICO_ADDR = pre_ico_address;
initAssign += assignTokens(wallet_address, 9227465 * multiplier);
uint presaleTokens = 0;
presaleTokens += assignTokens(address(0x72B16DC0e5f85aA4BBFcE81687CCc9D6871C2965), 230387 * multiplier);
presaleTokens += assignTokens(address(0x7270cC02d88Ea63FC26384f5d08e14EE87E75154), 132162 * multiplier);
presaleTokens += assignTokens(address(0x25F92f21222969BB0b1f14f19FBa770D30Ff678f), 132162 * multiplier);
presaleTokens += assignTokens(address(0xAc99C59D3353a34531Fae217Ba77139BBe4eDBb3), 443334 * multiplier);
presaleTokens += assignTokens(address(0x95c67812c5C41733419aC3b1916d2F282E7A15A4), 396486 * multiplier);
presaleTokens += assignTokens(address(0x1f5d30BB328498fF6E09b717EC22A9046C41C257), 20144 * multiplier);
presaleTokens += assignTokens(address(0x0a1ac564e95dAEDF8d454a3593b75CCdd474fc42), 19815 * multiplier);
presaleTokens += assignTokens(address(0x0C5448D5bC4C40b4d2b2c1D7E58E0541698d3e6E), 19815 * multiplier);
presaleTokens += assignTokens(address(0xFAe11D521538F067cE0B13B6f8C929cdEA934D07), 75279 * multiplier);
presaleTokens += assignTokens(address(0xEE51304603887fFF15c6d12165C6d96ff0f0c85b), 45949 * multiplier);
presaleTokens += assignTokens(address(0xd7Bab04C944faAFa232d6EBFE4f60FF8C4e9815F), 6127 * multiplier);
presaleTokens += assignTokens(address(0x603f39C81560019c8360F33bA45Bc1E4CAECb33e), 45949 * multiplier);
presaleTokens += assignTokens(address(0xBB5128f1093D1aa85F6d7D0cC20b8415E0104eDD), 15316 * multiplier);
initialTokensAssigned = true;
Deployed(totalSupply);
assert(presaleTokens == 3524578 * multiplier);
assert(totalSupply == (initAssign.add(presaleTokens)));
}
function assignTokens (address addr, uint amount) internal returns (uint) {
require(addr != 0x0);
require(initialTokensAssigned == false);
balances[addr] = amount;
Transfer(0x0, addr, balances[addr]);
return balances[addr];
}
function burn(uint256 _value) public onlyIfLockTimePassed {
require(_value > 0);
require(balances[msg.sender] >= _value);
require(totalSupply >= _value);
uint pre_balance = balances[msg.sender];
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
Transfer(burner, 0x0, _value);
assert(balances[burner] == pre_balance.sub(_value));
}
function transfer(address _to, uint256 _value) public onlyIfLockTimePassed returns (bool) {
require(_to != 0x0);
require(_to != address(this));
require(balances[msg.sender] >= _value);
require(balances[_to].add(_value) >= balances[_to]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transfer(
address _to,
uint256 _value,
bytes _data)
public
onlyIfLockTimePassed
returns (bool)
{
require(transfer(_to, _value));
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
return true;
}
function transfer(
address _to,
uint256 _value,
bytes _data)
public
onlyIfLockTimePassed
returns (bool)
{
require(transfer(_to, _value));
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
return true;
}
function transfer(
address _to,
uint256 _value,
bytes _data)
public
onlyIfLockTimePassed
returns (bool)
{
require(transfer(_to, _value));
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
public
onlyIfLockTimePassed
returns (bool)
{
require(_from != 0x0);
require(_to != 0x0);
require(_to != address(this));
require(balances[_from] >= _value);
require(allowed[_from][msg.sender] >= _value);
require(balances[_to].add(_value) >= balances[_to]);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public onlyIfLockTimePassed returns (bool) {
require(_spender != 0x0);
require(_value == 0 || allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender)
constant
public
returns (uint256)
{
return allowed[_owner][_spender];
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
}
| 12,976,621 | [
1,
8939,
45,
4232,
39,
3787,
23,
3155,
598,
18305,
14176,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
4360,
77,
1345,
353,
3155,
288,
203,
203,
203,
565,
533,
5381,
1071,
508,
273,
315,
8939,
45,
3155,
14432,
203,
565,
533,
5381,
1071,
3273,
273,
315,
8939,
45,
14432,
203,
565,
2254,
28,
5381,
1071,
15105,
273,
6549,
31,
203,
565,
1450,
14060,
10477,
364,
2254,
31,
203,
565,
2254,
5381,
15027,
273,
1728,
2826,
2254,
12,
31734,
1769,
203,
203,
565,
2874,
261,
2867,
516,
2254,
5034,
13,
324,
26488,
31,
203,
565,
2874,
261,
2867,
516,
2874,
261,
2867,
516,
2254,
5034,
3719,
2935,
31,
203,
203,
565,
2254,
5034,
1071,
2078,
3088,
1283,
273,
225,
4248,
3600,
8285,
4033,
380,
15027,
31,
203,
203,
565,
1426,
2172,
5157,
20363,
273,
629,
31,
203,
203,
565,
1758,
1071,
7071,
67,
2871,
51,
67,
14142,
31,
203,
565,
1758,
1071,
467,
3865,
67,
14142,
31,
203,
203,
565,
1758,
1071,
30293,
15146,
67,
14142,
31,
203,
203,
565,
2254,
1071,
2176,
950,
31,
203,
203,
565,
9606,
1338,
2047,
2531,
950,
22530,
1832,
288,
203,
3639,
2583,
12,
3338,
405,
2176,
950,
747,
261,
3576,
18,
15330,
422,
7071,
67,
2871,
51,
67,
14142,
747,
1234,
18,
15330,
422,
467,
3865,
67,
14142,
10019,
203,
3639,
389,
31,
203,
565,
289,
203,
203,
203,
565,
871,
7406,
329,
12,
11890,
8808,
389,
4963,
67,
2859,
1283,
1769,
203,
565,
445,
4360,
77,
1345,
12,
203,
3639,
1758,
277,
2894,
67,
2867,
16,
203,
3639,
1758,
675,
67,
10764,
67,
2867,
16,
203,
3639,
1758,
9230,
67,
2867,
16,
203,
3639,
2
] |
./full_match/42/0x57aE897c635b85C32f6E32736710c9D4d0beCf6A/sources/github/Canvinus/JamaicanDigitalCurrency/JamaicanDigitalCurrency.sol | Mints new tokens Only callable by an owner | function mint(uint256 amount) external isOwner {
_totalSupply += amount;
balances[msg.sender] = balances[msg.sender].add(amount);
emit Minted(msg.sender, amount);
}
| 16,252,477 | [
1,
49,
28142,
394,
2430,
225,
5098,
4140,
635,
392,
3410,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
312,
474,
12,
11890,
5034,
3844,
13,
3903,
353,
5541,
288,
203,
3639,
389,
4963,
3088,
1283,
1011,
3844,
31,
203,
3639,
324,
26488,
63,
3576,
18,
15330,
65,
273,
324,
26488,
63,
3576,
18,
15330,
8009,
1289,
12,
8949,
1769,
203,
203,
3639,
3626,
490,
474,
329,
12,
3576,
18,
15330,
16,
3844,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
// solhint-disable not-rely-on-time
pragma solidity ^0.8.3;
import "./openzeppelin-solidity/contracts/SafeMath.sol";
import "./openzeppelin-solidity/contracts/ReentrancyGuard.sol";
import "./openzeppelin-solidity/contracts/Ownable.sol";
import "./openzeppelin-solidity/contracts/ERC20/SafeERC20.sol";
import "./openzeppelin-solidity/contracts/ERC20/ERC20.sol";
// Inheritance
import "./interfaces/ILiquidityBond.sol";
// Interfaces
import "./interfaces/IReleaseEscrow.sol";
import "./interfaces/IPriceCalculator.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IUniswapV2Pair.sol";
import './interfaces/IUniswapV2Router02.sol';
import "./interfaces/IBackupMode.sol";
contract LiquidityBond is ILiquidityBond, ReentrancyGuard, Ownable, ERC20 {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
uint256 public constant MAX_PURCHASE_AMOUNT = 1e21; // 1000 CELO
uint256 public constant MIN_AVERAGE_FOR_PERIOD = 1e21; // 1000 CELO
uint256 public constant PERIOD_DURATION = 1 days;
IERC20 public immutable rewardsToken; // TGEN token
IERC20 public immutable collateralToken; // CELO token
IUniswapV2Pair public immutable lpPair; // TGEN-CELO LP pair on Ubeswap
IReleaseEscrow public releaseEscrow;
IPriceCalculator public immutable priceCalculator;
IRouter public immutable router;
IUniswapV2Router02 public immutable ubeswapRouter;
IBackupMode public backupMode;
address public immutable xTGEN;
uint256 public totalAvailableRewards;
uint256 public totalStakedAmount;
uint256 public rewardPerTokenStored;
uint256 public bondTokenPrice = 1e18; // Price of 1 bond token in USD
uint256 public startTime;
uint256 public totalLPTokens;
mapping(address => uint256) public userLPTokens;
// Keeps track of whether a user has migrated their bond tokens to the StakingRewards contract.
mapping(address => bool) public hasMigrated;
mapping(uint256 => uint256) public stakedAmounts; // Period index => amount of CELO staked
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
/* ========== CONSTRUCTOR ========== */
constructor(address _rewardsToken,
address _collateralTokenAddress,
address _lpPair, address _priceCalculatorAddress,
address _routerAddress, address _ubeswapRouterAddress,
address _xTGEN,
address _backupMode)
ERC20("LiquidityBond", "LB")
{
rewardsToken = IERC20(_rewardsToken);
collateralToken = IERC20(_collateralTokenAddress);
lpPair = IUniswapV2Pair(_lpPair);
priceCalculator = IPriceCalculator(_priceCalculatorAddress);
router = IRouter(_routerAddress);
ubeswapRouter = IUniswapV2Router02(_ubeswapRouterAddress);
backupMode = IBackupMode(_backupMode);
xTGEN = _xTGEN;
}
/* ========== VIEWS ========== */
/**
* @dev Returns whether the rewards have started.
*/
function hasStarted() public view override returns (bool) {
return block.timestamp >= startTime;
}
/**
* @dev Returns the period index of the given timestamp.
*/
function getPeriodIndex(uint256 _timestamp) public view override returns (uint256) {
return (_timestamp.sub(startTime)).div(PERIOD_DURATION);
}
/**
* @dev Calculates the amount of unclaimed rewards the user has available.
* @param _account address of the user.
* @return (uint256) amount of available unclaimed rewards.
*/
function earned(address _account) public view override returns (uint256) {
return (balanceOf(_account).mul(rewardPerTokenStored.sub(userRewardPerTokenPaid[_account])).div(1e18)).add(rewards[_account]);
}
/* ========== MUTATIVE FUNCTIONS ========== */
/**
* @dev Transfers LP tokens to the user and burns their LP tokens.
*/
function migrateBondTokens() external nonReentrant releaseEscrowIsSet {
require(backupMode.useBackup(), "LiquidityBond: Protocol must be in backup mode to migrate tokens.");
require(!hasMigrated[msg.sender], "LiquidityBond: Already migrated.");
uint256 numberOfLPTokens = userLPTokens[msg.sender];
uint256 numberOfBondTokens = balanceOf(msg.sender);
_claimReward();
IERC20(address(lpPair)).safeTransfer(msg.sender, numberOfLPTokens);
totalLPTokens = totalLPTokens.sub(numberOfLPTokens);
userLPTokens[msg.sender] = 0;
hasMigrated[msg.sender] = true;
_burn(msg.sender, numberOfBondTokens);
emit MigratedBondTokens(msg.sender, numberOfLPTokens, numberOfBondTokens);
}
/**
* @dev Purchases liquidity bonds.
* @notice Swaps 1/2 of collateral for TGEN and adds liquidity.
* @param _amount amount of collateral to deposit.
*/
function purchase(uint256 _amount) external override nonReentrant releaseEscrowIsSet rewardsHaveStarted updateReward(msg.sender) {
require(_amount > 0, "LiquidityBond: Amount must be positive.");
require(_amount <= MAX_PURCHASE_AMOUNT, "LiquidityBond: Amount must be less than max purchase amount.");
require(!backupMode.useBackup(), "LiquidityBond: Cannot purchase tokens when protocol is in backup mode.");
_getReward();
// Use the deposited collateral to add liquidity for TGEN-CELO.
collateralToken.safeTransferFrom(msg.sender, address(this), _amount);
// Add liquidity.
{
uint256 numberOfLPTokens = _addLiquidity(_amount);
userLPTokens[msg.sender] = userLPTokens[msg.sender].add(numberOfLPTokens);
totalLPTokens = totalLPTokens.add(numberOfLPTokens);
}
uint256 amountOfBonusCollateral = _calculateBonusAmount(_amount);
uint256 dollarValue = priceCalculator.getUSDPrice(address(collateralToken)).mul(_amount.add(amountOfBonusCollateral)).div(10 ** 18);
uint256 numberOfBondTokens = dollarValue.mul(10 ** 18).div(bondTokenPrice);
uint256 initialFlooredSupply = totalSupply().div(10 ** 21);
// Add original collateral amount to staked amount for current period; don't include bonus amount.
stakedAmounts[getPeriodIndex(block.timestamp)] = stakedAmounts[getPeriodIndex(block.timestamp)].add(_amount);
totalStakedAmount = totalStakedAmount.add(_amount);
// Increase total supply and transfer bond tokens to buyer.
_mint(msg.sender, numberOfBondTokens);
// Increase price by 1% for every 1000 tokens minted.
uint256 delta = (totalSupply().div(10 ** 21)).sub(initialFlooredSupply);
bondTokenPrice = bondTokenPrice.mul(101 ** delta).div(100 ** delta);
emit Purchased(msg.sender, _amount, numberOfBondTokens, amountOfBonusCollateral);
}
/**
* @dev Claims available rewards for the user.
*/
function getReward() public override nonReentrant releaseEscrowIsSet rewardsHaveStarted {
_getReward();
}
/**
* @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) internal virtual override {
if (from != address(0) && to != address(0)) {
_getReward();
rewards[to] = earned(to);
userRewardPerTokenPaid[to] = rewardPerTokenStored;
}
}
/* ========== INTERNAL FUNCTIONS ========== */
/**
* @dev Updates available rewards for the contracts and claims user's share of rewards.
*/
function _getReward() internal {
uint256 availableRewards = releaseEscrow.withdraw();
if (totalSupply() == 0) {
rewardsToken.safeTransfer(xTGEN, availableRewards);
}
else {
_addReward(availableRewards);
_claimReward();
}
}
/**
* @dev Claims available rewards for the user.
*/
function _claimReward() internal updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.transfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
/**
* @dev Updates the available rewards for the LiquidityBond contract, based on the release schedule.
* @param _reward number of tokens to add to the LiquidityBond contract.
*/
function _addReward(uint256 _reward) internal {
if (totalSupply() > 0) {
rewardPerTokenStored = rewardPerTokenStored.add(_reward.mul(1e18).div(totalSupply()));
}
totalAvailableRewards = totalAvailableRewards.add(_reward);
emit RewardAdded(_reward);
}
/**
* @dev Supplies liquidity for TGEN-CELO pair.
* @notice Transfers unused TGEN to xTGEN contract.
* @param _amountOfCollateral number of asset tokens to supply.
* @return (uint256) Number of LP tokens received.
*/
function _addLiquidity(uint256 _amountOfCollateral) internal returns (uint256) {
collateralToken.approve(address(router), _amountOfCollateral.div(2));
uint256 receivedTGEN = router.swapAssetForTGEN(address(collateralToken), _amountOfCollateral.div(2));
address token0 = lpPair.token0();
(uint112 reserve0, uint112 reserve1,) = lpPair.getReserves();
uint256 neededTGEN;
if (token0 == address(rewardsToken)) {
neededTGEN = ubeswapRouter.quote(_amountOfCollateral.div(2), reserve1, reserve0);
}
else {
neededTGEN = ubeswapRouter.quote(_amountOfCollateral.div(2), reserve0, reserve1);
}
collateralToken.approve(address(router), _amountOfCollateral.div(2));
rewardsToken.approve(address(router), neededTGEN);
router.addLiquidity(address(collateralToken), _amountOfCollateral.div(2), neededTGEN);
// Transfer unused TGEN to xTGEN contract.
rewardsToken.safeTransfer(xTGEN, receivedTGEN.sub(neededTGEN));
return router.addLiquidity(address(collateralToken), _amountOfCollateral.div(2), neededTGEN);
}
/**
* @dev Calculates the number of bonus tokens to consider as collateral when minting bond tokens.
* @notice The bonus multiplier for each period starts at +20% and falls linearly to +0% until max(1000, 1.1 * (totalSupply - amountStaked[n]) / (n-1))
* have been staked for the current period.
* @notice The final bonus amount is [(2ac - c^2) / 10m].
* @param _amountOfCollateral number of asset tokens to supply.
*/
function _calculateBonusAmount(uint256 _amountOfCollateral) internal view returns (uint256) {
uint256 currentPeriodIndex = getPeriodIndex(block.timestamp);
uint256 maxTokens = (currentPeriodIndex == 0) ? MIN_AVERAGE_FOR_PERIOD :
((totalStakedAmount.sub(stakedAmounts[currentPeriodIndex])).mul(11).div(currentPeriodIndex).div(10) > MIN_AVERAGE_FOR_PERIOD) ?
totalStakedAmount.sub(stakedAmounts[currentPeriodIndex]).mul(11).div(currentPeriodIndex).div(10) : MIN_AVERAGE_FOR_PERIOD;
uint256 availableTokens = (stakedAmounts[currentPeriodIndex] >= maxTokens) ? 0 : maxTokens.sub(stakedAmounts[currentPeriodIndex]);
uint256 availableCollateral = (availableTokens > _amountOfCollateral) ? _amountOfCollateral : availableTokens;
return ((availableTokens.mul(availableCollateral).mul(2).div(1e18)).sub(availableCollateral.mul(availableCollateral).div(1e18))).mul(1e18).div(maxTokens.mul(10));
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @dev Sets the address of the ReleaseEscrow contract.
* @notice This function can only be called once, and must be called before users can interact with LiquidityBond contract.
*/
function setReleaseEscrow(address _releaseEscrow) external onlyOwner releaseEscrowIsNotSet {
require(_releaseEscrow != address(0), "LiquidityBond: invalid address.");
releaseEscrow = IReleaseEscrow(_releaseEscrow);
startTime = releaseEscrow.startTime();
emit SetReleaseEscrow(_releaseEscrow, startTime);
}
/* ========== MODIFIERS ========== */
modifier updateReward(address account) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
_;
}
modifier releaseEscrowIsSet() {
require(address(releaseEscrow) != address(0), "LiquidityBond: ReleaseEscrow contract must be set before calling this function.");
_;
}
modifier releaseEscrowIsNotSet() {
require(address(releaseEscrow) == address(0), "LiquidityBond: ReleaseEscrow contract already set.");
_;
}
modifier rewardsHaveStarted() {
require(hasStarted(), "LiquidityBond: Rewards have not started.");
_;
}
/* ========== EVENTS ========== */
event RewardAdded(uint256 reward);
event Purchased(address indexed user, uint256 amountDeposited, uint256 numberOfBondTokensReceived, uint256 bonus);
event RewardPaid(address indexed user, uint256 reward);
event SetReleaseEscrow(address releaseEscrowAddress, uint256 startTime);
event MigratedBondTokens(address indexed user, uint256 numberOfLPTokensReceived, uint256 numberOfBondTokensBurned);
} | * @dev Transfers LP tokens to the user and burns their LP tokens./ | function migrateBondTokens() external nonReentrant releaseEscrowIsSet {
require(backupMode.useBackup(), "LiquidityBond: Protocol must be in backup mode to migrate tokens.");
require(!hasMigrated[msg.sender], "LiquidityBond: Already migrated.");
uint256 numberOfLPTokens = userLPTokens[msg.sender];
uint256 numberOfBondTokens = balanceOf(msg.sender);
_claimReward();
IERC20(address(lpPair)).safeTransfer(msg.sender, numberOfLPTokens);
totalLPTokens = totalLPTokens.sub(numberOfLPTokens);
userLPTokens[msg.sender] = 0;
hasMigrated[msg.sender] = true;
_burn(msg.sender, numberOfBondTokens);
emit MigratedBondTokens(msg.sender, numberOfLPTokens, numberOfBondTokens);
}
| 13,027,239 | [
1,
1429,
18881,
511,
52,
2430,
358,
326,
729,
471,
18305,
87,
3675,
511,
52,
2430,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
13187,
9807,
5157,
1435,
3903,
1661,
426,
8230,
970,
3992,
6412,
492,
15737,
288,
203,
3639,
2583,
12,
9572,
2309,
18,
1202,
6248,
9334,
315,
48,
18988,
24237,
9807,
30,
4547,
1297,
506,
316,
5114,
1965,
358,
13187,
2430,
1199,
1769,
203,
3639,
2583,
12,
5,
5332,
25483,
690,
63,
3576,
18,
15330,
6487,
315,
48,
18988,
24237,
9807,
30,
17009,
24741,
1199,
1769,
203,
203,
3639,
2254,
5034,
7922,
48,
1856,
3573,
273,
729,
48,
1856,
3573,
63,
3576,
18,
15330,
15533,
203,
3639,
2254,
5034,
7922,
9807,
5157,
273,
11013,
951,
12,
3576,
18,
15330,
1769,
203,
203,
3639,
389,
14784,
17631,
1060,
5621,
203,
203,
3639,
467,
654,
39,
3462,
12,
2867,
12,
9953,
4154,
13,
2934,
4626,
5912,
12,
3576,
18,
15330,
16,
7922,
48,
1856,
3573,
1769,
203,
203,
3639,
2078,
48,
1856,
3573,
273,
2078,
48,
1856,
3573,
18,
1717,
12,
2696,
951,
48,
1856,
3573,
1769,
203,
3639,
729,
48,
1856,
3573,
63,
3576,
18,
15330,
65,
273,
374,
31,
203,
3639,
711,
25483,
690,
63,
3576,
18,
15330,
65,
273,
638,
31,
203,
203,
3639,
389,
70,
321,
12,
3576,
18,
15330,
16,
7922,
9807,
5157,
1769,
203,
203,
3639,
3626,
490,
2757,
690,
9807,
5157,
12,
3576,
18,
15330,
16,
7922,
48,
1856,
3573,
16,
7922,
9807,
5157,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
import "base64-sol/base64.sol";
import "./constants/Colors.sol";
/// @title Hair SVG generator
library HairDetail {
/// @dev Hair Nยฐ1 => Classic Brown
function item_1() public pure returns (string memory) {
return base(classicHairs(Colors.BROWN));
}
/// @dev Hair Nยฐ2 => Classic Black
function item_2() public pure returns (string memory) {
return base(classicHairs(Colors.BLACK));
}
/// @dev Hair Nยฐ3 => Classic Gray
function item_3() public pure returns (string memory) {
return base(classicHairs(Colors.GRAY));
}
/// @dev Hair Nยฐ4 => Classic White
function item_4() public pure returns (string memory) {
return base(classicHairs(Colors.WHITE));
}
/// @dev Hair Nยฐ5 => Classic Blue
function item_5() public pure returns (string memory) {
return base(classicHairs(Colors.BLUE));
}
/// @dev Hair Nยฐ6 => Classic Yellow
function item_6() public pure returns (string memory) {
return base(classicHairs(Colors.YELLOW));
}
/// @dev Hair Nยฐ7 => Classic Pink
function item_7() public pure returns (string memory) {
return base(classicHairs(Colors.PINK));
}
/// @dev Hair Nยฐ8 => Classic Red
function item_8() public pure returns (string memory) {
return base(classicHairs(Colors.RED));
}
/// @dev Hair Nยฐ9 => Classic Purple
function item_9() public pure returns (string memory) {
return base(classicHairs(Colors.PURPLE));
}
/// @dev Hair Nยฐ10 => Classic Green
function item_10() public pure returns (string memory) {
return base(classicHairs(Colors.GREEN));
}
/// @dev Hair Nยฐ11 => Classic Saiki
function item_11() public pure returns (string memory) {
return base(classicHairs(Colors.SAIKI));
}
/// @dev Hair Nยฐ12 => Classic 2 Brown
function item_12() public pure returns (string memory) {
return base(classicTwoHairs(Colors.BROWN));
}
/// @dev Hair Nยฐ13 => Classic 2 Black
function item_13() public pure returns (string memory) {
return base(classicTwoHairs(Colors.BLACK));
}
/// @dev Hair Nยฐ14 => Classic 2 Gray
function item_14() public pure returns (string memory) {
return base(classicTwoHairs(Colors.GRAY));
}
/// @dev Hair Nยฐ15 => Classic 2 White
function item_15() public pure returns (string memory) {
return base(classicTwoHairs(Colors.WHITE));
}
/// @dev Hair Nยฐ16 => Classic 2 Blue
function item_16() public pure returns (string memory) {
return base(classicTwoHairs(Colors.BLUE));
}
/// @dev Hair Nยฐ17 => Classic 2 Yellow
function item_17() public pure returns (string memory) {
return base(classicTwoHairs(Colors.YELLOW));
}
/// @dev Hair Nยฐ18 => Classic 2 Pink
function item_18() public pure returns (string memory) {
return base(classicTwoHairs(Colors.PINK));
}
/// @dev Hair Nยฐ19 => Classic 2 Red
function item_19() public pure returns (string memory) {
return base(classicTwoHairs(Colors.RED));
}
/// @dev Hair Nยฐ20 => Classic 2 Purple
function item_20() public pure returns (string memory) {
return base(classicTwoHairs(Colors.PURPLE));
}
/// @dev Hair Nยฐ21 => Classic 2 Green
function item_21() public pure returns (string memory) {
return base(classicTwoHairs(Colors.GREEN));
}
/// @dev Hair Nยฐ22 => Classic 2 Saiki
function item_22() public pure returns (string memory) {
return base(classicTwoHairs(Colors.SAIKI));
}
/// @dev Hair Nยฐ23 => Short Black
function item_23() public pure returns (string memory) {
return base(shortHairs(Colors.BLACK));
}
/// @dev Hair Nยฐ24 => Short Blue
function item_24() public pure returns (string memory) {
return base(shortHairs(Colors.BLUE));
}
/// @dev Hair Nยฐ25 => Short Pink
function item_25() public pure returns (string memory) {
return base(shortHairs(Colors.PINK));
}
/// @dev Hair Nยฐ26 => Short White
function item_26() public pure returns (string memory) {
return base(shortHairs(Colors.WHITE));
}
/// @dev Hair Nยฐ27 => Spike Black
function item_27() public pure returns (string memory) {
return base(spike(Colors.BLACK));
}
/// @dev Hair Nยฐ28 => Spike Blue
function item_28() public pure returns (string memory) {
return base(spike(Colors.BLUE));
}
/// @dev Hair Nยฐ29 => Spike Pink
function item_29() public pure returns (string memory) {
return base(spike(Colors.PINK));
}
/// @dev Hair Nยฐ30 => Spike White
function item_30() public pure returns (string memory) {
return base(spike(Colors.WHITE));
}
/// @dev Hair Nยฐ31 => Monk
function item_31() public pure returns (string memory) {
return base(monk());
}
/// @dev Hair Nยฐ32 => Nihon
function item_32() public pure returns (string memory) {
return
base(
string(
abi.encodePacked(
monk(),
'<path opacity="0.36" fill="#6E5454" stroke="#8A8A8A" stroke-width="0.5" stroke-miterlimit="10" d=" M287.5,206.8c0,0,0.1-17.4-2.9-20.3c-3.1-2.9-7.3-8.7-7.3-8.7s0.6-24.8-2.9-31.8c-3.6-7-3.9-24.3-35-23.6 c-30.3,0.7-42.5,5.4-42.5,5.4s-14.2-8.2-43-3.8c-19.3,4.9-17.2,50.1-17.2,50.1s-5.6,9.5-6.2,14.8c-0.6,5.3-0.3,8.3-0.3,8.3 S111,72.1,216.8,70.4c108.4-1.7,87.1,121.7,85.1,122.4C295.4,190.1,293.9,197.7,287.5,206.8z"/>',
'<g opacity="0.33">',
'<ellipse transform="matrix(0.7071 -0.7071 0.7071 0.7071 0.367 227.089)" fill="#FFFFFF" cx="274.3" cy="113.1" rx="1.4" ry="5.3"/>',
'<ellipse transform="matrix(0.5535 -0.8328 0.8328 0.5535 32.4151 255.0608)" fill="#FFFFFF" cx="254.1" cy="97.3" rx="4.2" ry="16.3"/>',
"</g>",
'<path fill="#FFFFFF" stroke="#2B232B" stroke-miterlimit="10" d="M136.2,125.1c0,0,72,9.9,162.2,0c0,0,4.4,14.9,4.8,26.6 c0,0-125.4,20.9-172.6-0.3C129.5,151.3,132.9,130.3,136.2,125.1z"/>',
'<polygon fill="#FFFFFF" stroke="#2B232B" stroke-miterlimit="10" points="306.2,138 324.2,168.1 330,160"/>',
'<path fill="#FFFFFF" stroke="#2B232B" stroke-miterlimit="10" d="M298.4,125.1l34.2,54.6l-18,15.5l-10.7-43.5 C302.3,142.2,299.9,128.8,298.4,125.1z"/>',
'<ellipse opacity="0.87" fill="#FF0039" cx="198.2" cy="144.1" rx="9.9" ry="10.8"/>'
)
)
);
}
/// @dev Hair Nยฐ33 => Bald
function item_33() public pure returns (string memory) {
return
base(
string(
abi.encodePacked(
'<ellipse transform="matrix(0.7071 -0.7071 0.7071 0.7071 0.1733 226.5807)" fill="#FFFFFF" cx="273.6" cy="113.1" rx="1.4" ry="5.3"/>',
'<ellipse transform="matrix(0.5535 -0.8328 0.8328 0.5535 32.1174 254.4671)" fill="#FFFFFF" cx="253.4" cy="97.3" rx="4.2" ry="16.3"/>'
)
)
);
}
/// @dev Generate classic hairs with the given color
function classicHairs(string memory hairsColor) private pure returns (string memory) {
return
string(
abi.encodePacked(
"<path fill='#",
hairsColor,
"' stroke='#000000' stroke-width='0.5' stroke-miterlimit='10' d='M252.4,71.8c0,0-15.1-13.6-42.6-12.3l15.6,8.8c0,0-12.9-0.9-28.4-1.3c-6.1-0.2-21.8,3.3-38.3-1.4c0,0,7.3,7.2,9.4,7.7c0,0-30.6,13.8-47.3,34.2c0,0,10.7-8.9,16.7-10.9c0,0-26,25.2-31.5,70c0,0,9.2-28.6,15.5-34.2c0,0-10.7,27.4-5.3,48.2c0,0,2.4-14.5,4.9-19.2c-1,14.1,2.4,33.9,13.8,47.8c0,0-3.3-15.8-2.2-21.9l8.8-17.9c0.1,4.1,1.3,8.1,3.1,12.3c0,0,13-36.1,19.7-43.9c0,0-2.9,15.4-1.1,29.6c0,0,6.8-23.5,16.9-36.8c0,0-4.6,15.6-2.7,31.9c0,0,9.4-26.2,10.4-28.2l-2.7,9.2c0,0,4.1,21.6,3.8,25.3c0,0,8.4-10.3,21.2-52l-2.9,12c0,0,9.8,20.3,10.3,22.2s-1.3-13.9-1.3-13.9s12.4,21.7,13.5,26c0,0,5.5-20.8,3.4-35.7l1.1,9.6c0,0,15,20.3,16.4,30.1s-0.1-23.4-0.1-23.4s13.8,30.6,17,39.4c0,0,1.9-17,1.4-19.4s8.5,34.6,4.4,46c0,0,11.7-16.4,11.5-21.4c1.4,0.8-1.3,22.6-4,26.3c0,0,3.2-0.3,8.4-9.3c0,0,11.1-13.4,11.8-11.7c0.7,1.7,1.8-2.9,5.5,10.2l2.6-7.6c0,0-0.4,15.4-3.3,21.4c0,0,14.3-32.5,10.4-58.7c0,0,3.7,9.3,4.4,16.9s3.1-32.8-7.7-51.4c0,0,6.9,3.9,10.8,4.8c0,0-12.6-12.5-13.6-15.9c0,0-14.1-25.7-39.1-34.6c0,0,9.3-3.2,15.6,0.2C286.5,78.8,271.5,66.7,252.4,71.8z'/>",
'<path fill="none" stroke="#000000" stroke-width="0.5" stroke-miterlimit="10" d="M286,210c0,0,8.5-10.8,8.6-18.7"/>',
'<path fill="none" stroke="#000000" stroke-width="0.5" stroke-linecap="round" stroke-miterlimit="10" d="M132.5,190.4c0,0-1.3-11.3,0.3-16.9"/>',
'<path fill="none" stroke="#000000" stroke-width="0.5" stroke-linecap="round" stroke-miterlimit="10" d="M141.5,170c0,0-1-6.5,1.6-20.4"/>',
'<path opacity="0.2" d="M267.7,151.7l-0.3,30.9c0,0,1.9-18.8,1.8-19.3s8.6,43.5,3.9,47.2c0,0,11.9-18.8,12.1-21.5s0,22-3.9,25c0,0,6-4.4,8.6-10.1c0,0,6.1-7,9.9-10.7c0,0,3.9-1,6.8,8.2l2.8-6.9c0,0,0.1,13.4-1.3,16.1c0,0,10.5-28.2,7.9-52.9c0,0,4.7,8.3,4.9,17.1c0.1,8.8,1.7-8.6,0.2-17.8c0,0-6.5-13.9-8.2-15.4c0,0,2.2,14.9,1.3,18.4c0,0-8.2-15.1-11.4-17.3c0,0,1.2,41-1.6,46.1c0,0-6.8-22.7-11.4-26.5c0,0,0.7,17.4-3.6,23.2C284.5,183.3,280.8,169.9,267.7,151.7z"/>',
'<path opacity="0.2" d="M234.3,137.1c0,0,17.1,23.2,16.7,30.2s-0.2-13.3-0.2-13.3s-11.7-22-17.6-26.2L234.3,137.1z"/>',
'<polygon opacity="0.2" points="250.7,143.3 267.5,162.9 267.3,181.9"/>',
'<path opacity="0.2" d="M207.4,129.2l9.7,20.7l-1-13.7c0,0,11.6,21,13.5,25.4l1.4-5l-17.6-27.4l1,7.5l-6-12.6L207.4,129.2z"/>',
'<path opacity="0.2" d="M209.2,118c0,0-13.7,36.6-18.5,40.9c-1.7-7.2-1.9-7.9-4.2-20.3c0,0-0.1,2.7-1.4,5.3c0.7,8.2,4.1,24.4,4,24.5S206.4,136.6,209.2,118z"/>',
'<path opacity="0.2" d="M187.6,134.7c0,0-9.6,25.5-10,26.9l-0.4-3.6C177.1,158.1,186.8,135.8,187.6,134.7z"/>',
'<path opacity="0.2" fill-rule="evenodd" clip-rule="evenodd" d="M180.7,129.6c0,0-16.7,22.3-17.7,24.2s0,12.4,0.3,12.8S165.9,153,180.7,129.6z"/>',
'<path opacity="0.2" fill-rule="evenodd" clip-rule="evenodd" d="M180.4,130.6c0,0-0.2,20.5-0.6,21.5c-0.4,0.9-2.6,5.8-2.6,5.8S176.1,147.1,180.4,130.6z"/>',
abi.encodePacked(
'<path opacity="0.2" d="M163.9,138c0,0-16.3,25.3-17.9,26.3c0,0-3.8-12.8-3-14.7s-9.6,10.3-9.9,17c0,0-8.4-0.6-11-7.4c-1-2.5,1.4-9.1,2.1-12.2c0,0-6.5,7.9-9.4,22.5c0,0,0.6,8.8,1.1,10c0,0,3.5-14.8,4.9-17.7c0,0-0.3,33.3,13.6,46.7c0,0-3.7-18.6-2.6-21l9.4-18.6c0,0,2.1,10.5,3.1,12.3l13.9-33.1L163.9,138z"/>',
'<path fill="#FFFFFF" d="M204,82.3c0,0-10.3,24.4-11.5,30.4c0,0,11.1-20.6,12.6-20.8c0,0,11.4,20.4,12,22.2C217.2,114.1,208.2,88.2,204,82.3z"/>',
'<path fill="#FFFFFF" d="M185.6,83.5c0,0-1,29.2,0,39.2c0,0-4-21.4-3.6-25.5c0.4-4-13.5,19.6-16,23.9c0,0,7.5-20.6,10.5-25.8c0,0-14.4,9.4-22,21.3C154.6,116.7,170.1,93.4,185.6,83.5z"/>',
'<path fill="#FFFFFF" d="M158.6,96.2c0,0-12,15.3-14.7,23.2"/>',
'<path fill="#FFFFFF" d="M125.8,125.9c0,0,9.5-20.6,23.5-27.7"/>',
'<path fill="#FFFFFF" d="M296.5,121.6c0,0-9.5-20.6-23.5-27.7"/>',
'<path fill="#FFFFFF" d="M216.1,88.5c0,0,10.9,19.9,11.6,23.6s3.7-5.5-10.6-23.6"/>',
'<path fill="#FFFFFF" d="M227,92c0,0,21.1,25.4,22,27.4s-4.9-23.8-12.9-29.5c0,0,9.5,20.7,9.9,21.9C246.3,113,233.1,94.1,227,92z"/>',
'<path fill="#FFFFFF" d="M263.1,119.5c0,0-9.5-26.8-10.6-28.3s15.5,14.1,16.2,22.5c0,0-11.1-16.1-11.8-16.9C256.1,96,264.3,114.1,263.1,119.5z"/>'
)
)
);
}
/// @dev Generate classic 2 hairs with the given color
function classicTwoHairs(string memory hairsColor) private pure returns (string memory) {
return
string(
abi.encodePacked(
"<polygon fill='#",
hairsColor,
"' points='188.2,124.6 198.3,128.1 211.2,124.3 197.8,113.2'/>",
'<polygon opacity="0.5" points="188.4,124.7 198.3,128.1 211.7,124.2 197.7,113.6"/>',
"<path fill='#",
hairsColor,
"' stroke='#000000' stroke-width='0.5' stroke-miterlimit='10' d='M274,209.6c1,0.9,10.1-12.8,10.5-18.3 c1.1,3.2-0.2,16.8-2.9,20.5c0,0,3.7-0.7,8.3-6.5c0,0,11.1-13.4,11.8-11.7c0.7,1.7,1.8-2.9,5.5,10.2l2.6-7.6 c0,0-0.4,15.4-3.3,21.4c0,0,14.3-32.5,10.4-58.7c0,0,3.7,9.3,4.4,16.9s3.1-32.8-7.7-51.4c0,0,6.9,3.9,10.8,4.8 c0,0-12.6-12.5-13.6-15.9c0,0-14.1-25.7-39.1-34.6c0,0,9.3-3.2,15.6,0.2c-0.1-0.1-15.1-12.2-34.2-7.1c0,0-15.1-13.6-42.6-12.3 l15.6,8.8c0,0-12.9-0.9-28.4-1.3c-6.1-0.2-21.8,3.3-38.3-1.4c0,0,7.3,7.2,9.4,7.7c0,0-30.6,13.8-47.3,34.2 c0,0,10.7-8.9,16.7-10.9c0,0-26,25.2-31.5,70c0,0,9.2-28.6,15.5-34.2c0,0-10.7,27.4-5.3,48.2c0,0,2.4-14.5,4.9-19.2 c-1,14.1,2.4,33.9,13.8,47.8c0,0-3.3-15.8-2.2-21.9l8.8-17.9c0.1,4.1,1.3,8.1,3.1,12.3c0,0,13-36.1,19.7-43.9 c0,0-2.9,15.4-1.1,29.6c0,0,7.2-26.8,17.3-40.1c0,0,0.8,0.1,17.6-7.6c6.3,3.1,8,1.4,17.9,7.7c4.1,5.3,13.8,31.9,15.6,41.5 c3.4-7.3,5.6-19,5.2-29.5c2.7,3.7,8.9,19.9,9.6,34.3c0,0,7.9-15.9,5.9-29c0-0.2,0.2,14.5,0.3,14.3c0,0,12.1,19.9,14.9,19.7 c0-0.8-1.7-12.9-1.7-12.8c1.3,5.8,2.8,23.3,3.1,27.1l5-9.5C276.2,184,276.8,204.9,274,209.6z'/>",
'<path fill="none" stroke="#000000" stroke-width="0.5" stroke-miterlimit="10" d="M286.7,210c0,0,8.5-10.8,8.6-18.7"/>',
'<path fill="none" stroke="#000000" stroke-width="0.5" stroke-linecap="round" stroke-miterlimit="10" d="M133.2,190.4 c0,0-1.3-11.3,0.3-16.9"/>',
abi.encodePacked(
'<path fill="none" stroke="#000000" stroke-width="0.5" stroke-linecap="round" stroke-miterlimit="10" d="M142.2,170 c0,0-1-6.5,1.6-20.4"/>',
'<path opacity="0.2" fill-rule="evenodd" clip-rule="evenodd" d="M180.6,128.2 c0,0-15.9,23.7-16.9,25.6s0,12.4,0.3,12.8S165.8,151.6,180.6,128.2z"/>',
'<path opacity="0.2" d="M164.6,138c0,0-16.3,25.3-17.9,26.3c0,0-3.8-12.8-3-14.7s-9.6,10.3-9.9,17 c0,0-8.4-0.6-11-7.4c-1-2.5,1.4-9.1,2.1-12.2c0,0-6.5,7.9-9.4,22.5c0,0,0.6,8.8,1.1,10c0,0,3.5-14.8,4.9-17.7 c0,0-0.3,33.3,13.6,46.7c0,0-3.7-18.6-2.6-21l9.4-18.6c0,0,2.1,10.5,3.1,12.3l13.9-33.1L164.6,138z"/>',
'<path opacity="0.16" d="M253.3,155.9c0.8,4.4,8.1,12.1,13.1,11.7l1.6,11c0,0-5.2-3.9-14.7-19.9 V155.9z"/>',
'<path opacity="0.16" d="M237.6,139.4c0,0,4.4,3,13.9,21.7c0,0-4.3,12-4.6,12.4 C246.6,173.9,248.5,162.8,237.6,139.4z"/>',
'<path opacity="0.17" d="M221,136.7c0,0,5.2,4,14.4,23c0,0-1.2,4.6-3.1,8.9 C227.7,152.4,227.1,149.9,221,136.7z"/>',
'<path opacity="0.2" d="M272.1,152.6c-2.4,8.1-3.6,13.8-4.9,17.9c0,0,1.3,12.8,2.1,22.2 c4.7-8.4,5.4-8.8,5.4-9c-0.1-0.5,3.6,11.2-0.7,25.9c1.6,1,13.3-16.9,11.9-20.6c-1-2.5-0.4,19.8-4.3,22.8c0,0,6.4-2.2,9-7.9 c0,0,6.1-7,9.9-10.7c0,0,3.9-1,6.8,8.2l2.8-6.9c0,0,0.1,13.4-1.3,16.1c0,0,10.5-28.2,7.9-52.9c0,0,4.7,8.3,4.9,17.1 c0.1,8.8,1.7-8.6,0.2-17.8c0,0-6.5-13.9-8.2-15.4c0,0,2.2,14.9,1.3,18.4c0,0-8.2-15.1-11.4-17.3c0,0,1.2,41-1.6,46.1 c0,0-6.8-22.7-11.4-26.5c0,0-1.8,15.7-5,22.9C283.7,183,280.5,166.7,272.1,152.6z"/>'
),
abi.encodePacked(
'<path opacity="0.14" d="M198.2,115.2c-0.9-3.9,3.2-35.1,34.7-36C227.6,78.5,198.9,99.8,198.2,115.2z"/>',
'<g opacity="0.76">',
'<path fill="#FFFFFF" d="M153,105.9c0,0-12,15.3-14.7,23.2"/>',
'<path fill="#FFFFFF" d="M126.5,125.9c0,0,9.5-20.6,23.5-27.7"/>',
'<path fill="#FFFFFF" d="M297.2,121.6c0,0-9.5-20.6-23.5-27.7"/>',
'<path fill="#FFFFFF" d="M241.9,109.4c0,0,10.9,19.9,11.6,23.6s3.7-5.5-10.6-23.6"/>',
'<path fill="#FFFFFF" d="M155.1,117.3c0,0-10.9,19.9-11.6,23.6s-3.7-5.5,10.6-23.6"/>',
'<path fill="#FFFFFF" d="M256.1,101.5c0,0,21.1,25.4,22,27.4c0.9,2-4.9-23.8-12.9-29.5c0,0,9.5,20.7,9.9,21.9 C275.4,122.5,262.2,103.6,256.1,101.5z"/>',
'<path fill="#FFFFFF" d="M230,138.5c0,0-12.9-24.9-14.1-26.4c-1.2-1.4,18.2,11.9,19.3,20.2c0,0-11.9-13-12.7-13.7 C221.8,117.9,230.9,133,230,138.5z"/>',
'<path fill="#FFFFFF" d="M167,136.6c0,0,15.5-24.5,17-25.8c1.5-1.2-19.1,10.6-21.6,18.8c0,0,15-13.5,15.8-14.2 C179.2,114.8,166.8,130.9,167,136.6z"/>',
"</g>"
)
)
);
}
/// @dev Generate mohawk with the given color
function spike(string memory hairsColor) private pure returns (string memory) {
return
string(
abi.encodePacked(
"<path fill='#",
hairsColor,
"' d='M287.3,207.1c0,0-0.4-17.7-3.4-20.6c-3.1-2.9-7.3-8.7-7.3-8.7s0.6-24.8-2.9-31.8c-3.6-7-3.9-24.3-35-23.6c-30.3,0.7-42.5,5.4-42.5,5.4s-14.2-8.2-43-3.8c-19.3,4.9-17.2,50.1-17.2,50.1s-5.6,9.5-6.2,14.8c-0.6,5.3-0.3,8.3-0.3,8.3c0.9-0.2-19.1-126.3,86.7-126.8c108.4-0.3,87.1,121.7,85.1,122.4C294.5,191.6,293.7,198,287.3,207.1z'/>",
'<path fill-rule="evenodd" clip-rule="evenodd" fill="#212121" stroke="#000000" stroke-miterlimit="10" d="M196,124.6c0,0-30.3-37.5-20.6-77.7c0,0,0.7,18,12,25.1c0,0-8.6-13.4-0.3-33.4c0,0,2.7,15.8,10.7,23.4c0,0-2.7-18.4,2.2-29.6c0,0,9.7,23.2,13.9,26.3c0,0-6.5-17.2,5.4-27.7c0,0-0.8,18.6,9.8,25.4c0,0-2.7-11,4-18.9c0,0,1.2,25.1,6.6,29.4c0,0-2.7-12,2.1-20c0,0,6,24,8.6,28.5c-9.1-2.6-17.9-3.2-26.6-3C223.7,72.3,198,80.8,196,124.6z"/>',
crop()
)
);
}
function shortHairs(string memory hairsColor) private pure returns (string memory) {
return
string(
abi.encodePacked(
"<path fill='#",
hairsColor,
"' d='M287.3,207.1c0,0-0.4-17.7-3.4-20.6c-3.1-2.9-7.3-8.7-7.3-8.7s0.6-24.8-2.9-31.8c-3.6-7-3.9-24.3-35-23.6c-30.3,0.7-42.5,5.4-42.5,5.4s-14.2-8.2-43-3.8c-19.3,4.9-17.2,50.1-17.2,50.1s-5.6,9.5-6.2,14.8c-0.6,5.3-0.3,8.3-0.3,8.3c0.9-0.2-19.1-126.3,86.7-126.8c108.4-0.3,87.1,121.7,85.1,122.4C294.5,191.6,293.7,198,287.3,207.1z'/>",
'<path fill="#212121" stroke="#000000" stroke-miterlimit="10" d="M134.9,129.3c1-8.7,2.8-19.9,2.6-24.1 c1.1,2,4.4,6.1,4.7,6.9c2-15.1,3.9-18.6,6.6-28.2c0.1,5.2,0.4,6.1,4.6,11.9c0.1-7,4.5-17.6,8.8-24.3c0.6,3,4,8.2,5.8,10.7 c2.4-7,8.6-13.4,14.5-17.9c-0.3,3.4-0.1,6.8,0.7,10.1c4.9-5.1,7.1-8.7,15.6-15.4c-0.2,4.5,1.8,9,5.1,12c4.1-3.7,7.7-8,10.6-12.7 c0.6,3.7,1.4,7.3,2.5,10.8c2.6-4.6,7.9-8.4,12.4-11.3c1.5,3.5,1.3,11,5.9,11.7c7.1,1.1,10-3.3,11.4-10.1 c2.2,6.6,4.8,12.5,9.4,17.7c4.2,0.5,5.7-5.6,4.2-9c4.2,5.8,8.4,11.6,12.5,17.4c0.7-2.9,0.9-5.9,0.6-8.8 c3.4,7.6,9.1,16.7,13.6,23.6c0-1.9,1.8-8.5,1.8-10.4c2.6,7.3,7.7,17.9,10.3,36.6c0.2,1.1-23.8,7.5-28.8,10.1 c-1.2-2.3-2.2-4.3-6.2-8c-12.1-5.7-35.6-7.9-54.5-2.2c-16.3,4.8-21.5-2.3-31.3-3.1c-11.8-1.8-31.1-1.7-36.2,10.7 C139.6,133.6,137.9,132.2,134.9,129.3z"/>',
'<polygon fill="#212121" points="270.7,138.4 300.2,129 300.7,131.1 271.3,139.9"/>',
'<polygon fill="#212121" points="141.1,137 134,131.7 133.8,132.9 140.8,137.7 "/>',
crop()
)
);
}
/// @dev Generate crop SVG
function crop() private pure returns (string memory) {
return
string(
abi.encodePacked(
'<g id="Light" opacity="0.14">',
'<ellipse transform="matrix(0.7071 -0.7071 0.7071 0.7071 0.1603 226.5965)" fill="#FFFFFF" cx="273.6" cy="113.1" rx="1.4" ry="5.3"/>',
'<ellipse transform="matrix(0.5535 -0.8328 0.8328 0.5535 32.0969 254.4865)" fill="#FFFFFF" cx="253.4" cy="97.3" rx="4.2" ry="16.3"/>',
"</g>",
'<path opacity="0.05" fill-rule="evenodd" clip-rule="evenodd" d="M276.4,163.7c0,0,0.2-1.9,0.2,14.1c0,0,6.5,7.5,8.5,11s2.6,17.8,2.6,17.8l7-11.2c0,0,1.8-3.2,6.6-2.6c0,0,5.6-13.1,2.2-42.2C303.5,150.6,294.2,162.1,276.4,163.7z"/>',
'<path opacity="0.1" fill-rule="evenodd" clip-rule="evenodd" d="M129.2,194.4c0,0-0.7-8.9,6.8-20.3c0,0-0.2-21.2,1.3-22.9c-3.7,0-6.7-0.5-7.7-2.4C129.6,148.8,125.8,181.5,129.2,194.4z"/>'
)
);
}
/// @dev Generate monk SVG
function monk() private pure returns (string memory) {
return
string(
abi.encodePacked(
'<path opacity="0.36" fill="#6E5454" stroke="#8A8A8A" stroke-width="0.5" stroke-miterlimit="10" d="M286.8,206.8c0,0,0.1-17.4-2.9-20.3c-3.1-2.9-7.3-8.7-7.3-8.7s0.6-24.8-2.9-31.8c-3.6-7-3.9-24.3-35-23.6c-30.3,0.7-42.5,5.4-42.5,5.4s-14.2-8.2-43-3.8c-19.3,4.9-17.2,50.1-17.2,50.1s-5.6,9.5-6.2,14.8c-0.6,5.3-0.3,8.3-0.3,8.3S110.3,72.1,216.1,70.4c108.4-1.7,87.1,121.7,85.1,122.4C294.7,190.1,293.2,197.7,286.8,206.8z"/>',
'<g id="Bald" opacity="0.33">',
'<ellipse transform="matrix(0.7071 -0.7071 0.7071 0.7071 0.1603 226.5965)" fill="#FFFFFF" cx="273.6" cy="113.1" rx="1.4" ry="5.3"/>',
'<ellipse transform="matrix(0.5535 -0.8328 0.8328 0.5535 32.0969 254.4865)" fill="#FFFFFF" cx="253.4" cy="97.3" rx="4.2" ry="16.3"/>',
"</g>"
)
);
}
/// @notice Return the hair cut name of the given id
/// @param id The hair Id
function getItemNameById(uint8 id) public pure returns (string memory name) {
name = "";
if (id == 1) {
name = "Classic Brown";
} else if (id == 2) {
name = "Classic Black";
} else if (id == 3) {
name = "Classic Gray";
} else if (id == 4) {
name = "Classic White";
} else if (id == 5) {
name = "Classic Blue";
} else if (id == 6) {
name = "Classic Yellow";
} else if (id == 7) {
name = "Classic Pink";
} else if (id == 8) {
name = "Classic Red";
} else if (id == 9) {
name = "Classic Purple";
} else if (id == 10) {
name = "Classic Green";
} else if (id == 11) {
name = "Classic Saiki";
} else if (id == 12) {
name = "Classic Brown";
} else if (id == 13) {
name = "Classic 2 Black";
} else if (id == 14) {
name = "Classic 2 Gray";
} else if (id == 15) {
name = "Classic 2 White";
} else if (id == 16) {
name = "Classic 2 Blue";
} else if (id == 17) {
name = "Classic 2 Yellow";
} else if (id == 18) {
name = "Classic 2 Pink";
} else if (id == 19) {
name = "Classic 2 Red";
} else if (id == 20) {
name = "Classic 2 Purple";
} else if (id == 21) {
name = "Classic 2 Green";
} else if (id == 22) {
name = "Classic 2 Saiki";
} else if (id == 23) {
name = "Short Black";
} else if (id == 24) {
name = "Short Blue";
} else if (id == 25) {
name = "Short Pink";
} else if (id == 26) {
name = "Short White";
} else if (id == 27) {
name = "Spike Black";
} else if (id == 28) {
name = "Spike Blue";
} else if (id == 29) {
name = "Spike Pink";
} else if (id == 30) {
name = "Spike White";
} else if (id == 31) {
name = "Monk";
} else if (id == 32) {
name = "Nihon";
} else if (id == 33) {
name = "Bald";
}
}
/// @dev The base SVG for the hair
function base(string memory children) private pure returns (string memory) {
return string(abi.encodePacked('<g id="Hair">', children, "</g>"));
}
}
| @dev Hair Nยฐ19 => Classic 2 Red | function item_19() public pure returns (string memory) {
return base(classicTwoHairs(Colors.RED));
}
| 1,028,763 | [
1,
44,
1826,
423,
131,
113,
3657,
516,
26902,
576,
4621,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
761,
67,
3657,
1435,
1071,
16618,
1135,
261,
1080,
3778,
13,
288,
203,
3639,
327,
1026,
12,
1106,
335,
11710,
44,
1826,
87,
12,
12570,
18,
5879,
10019,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity ^0.4.24;
import "../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
/**
* @title Companies Contract
* @dev The contract used to save companies data.
*/
contract Companies {
using SafeMath for uint256;
struct Company {
uint256[] suppliers;
uint256[] importedEmissions;
uint256[] emissionsReports;
bytes32 name;
}
Company[] private company;
uint256 totalCompanies;
/**
* @dev Constructor
*/
constructor() public {
totalCompanies = 0;
}
/**
* @dev Upload information about emissions
* @return An uint256 with the emission id
*/
function upload(
uint256[] memory _suppliers,
uint256[] memory _importedEmissions,
uint256[] memory _emissionsReports,
bytes32 _name)
public returns(uint256) {
company.push(Company(_suppliers, _importedEmissions, _emissionsReports, _name));
totalCompanies = totalCompanies.add(1);
return totalCompanies;
}
/**
* @dev Gets the saved number.
* @return An uint256 representing the saved number.
*/
function getTotal() public view returns (uint256) {
return totalCompanies;
}
/**
* Since the structure of a company is a list of things, let's first
* return those list sizes
* @dev Get company information (array sizes for example)
* @return Needed information
*/
function get(uint256 _index) public view returns (uint256, uint256, uint256, bytes32) {
return(
company[_index].suppliers.length,
company[_index].importedEmissions.length,
company[_index].emissionsReports.length,
company[_index].name
);
}
/**
* @dev Get supplier information
* @return Supplier information
*/
function getSupplier(uint256 _companyIndex, uint256 _supplierIndex)
public view returns (uint256) {
return(company[_companyIndex].suppliers[_supplierIndex]);
}
function getEmission(uint256 _companyIndex, uint256 _emissionIndex)
public view returns(uint256) {
return(company[_companyIndex].emissionsReports[_emissionIndex]);
}
function addEmission(uint256 _companyIndex, uint256 _emissionIndex) public {
company[_companyIndex].emissionsReports.push(_emissionIndex);
}
}
| * @dev Gets the saved number. @return An uint256 representing the saved number./ | function getTotal() public view returns (uint256) {
return totalCompanies;
}
| 12,964,755 | [
1,
3002,
326,
5198,
1300,
18,
327,
1922,
2254,
5034,
5123,
326,
5198,
1300,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
12831,
1435,
1071,
1476,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
2078,
2945,
27891,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/3/0xB6460F9748Eb5A48c79cCC8ad48E0ea349A56336/sources/SushiToken.sol | @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef). | {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
| 5,111,111 | [
1,
2729,
1375,
67,
8949,
68,
1147,
358,
1375,
67,
869,
8338,
6753,
1338,
506,
2566,
635,
326,
3410,
261,
7786,
39,
580,
74,
2934,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
288,
203,
3639,
389,
81,
474,
24899,
869,
16,
389,
8949,
1769,
203,
3639,
389,
8501,
15608,
815,
12,
2867,
12,
20,
3631,
389,
3771,
1332,
815,
63,
67,
869,
6487,
389,
8949,
1769,
203,
565,
289,
203,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract NFTMOD is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;
struct Auction{
uint startTime;
uint endTime;
uint highestBid;
address highestBidder;
uint tokenID;
}
event AuctionCreated(
uint indexed auctionID,
uint indexed tokenID,
uint startTime,
uint endTime
);
event AuctionEnded(
uint indexed auctionID,
uint indexed tokenID
);
event BidSubmitted(
uint indexed auctionID,
uint indexed tokenID,
uint bidAmount,
address bidder
);
event BidTokenClaimed(
uint indexed auctionID,
uint indexed tokenID,
address highestBidder
);
event BidAmountWithdrawn(
uint indexed auctionID,
uint amount,
address bidder
);
event NFTsWereMinted();
mapping(uint=>Auction) public auctions;
//auctionID=>bidderAddress=>bidAmount
mapping(uint=>mapping(address=>uint)) biddings;
//tokenID=>auctionID
mapping(uint=>uint) currentTokenAuctionMapping;
// Set to true when 10 NFTs are minted
bool NFTsMinted = false;
Counters.Counter private _auctionIDs;
Counters.Counter private _tokenIds;
string public baseTokenURI;
constructor(string memory baseURI) ERC721("MyNFTs", "NFT") {
setBaseURI(baseURI);
}
function startAuction(uint tokenID) public onlyOwner() returns(uint) {
//uint prevAuctionID=currentTokenAuctionMapping[tokenID];
//require(auctions[prevAuctionID].endTime<block.timestamp,"Auction of this NFT is ongoing");
//uint currentAuctionID=_auctionIDs.current();
uint currentAuctionID=currentTokenAuctionMapping[tokenID];
require(auctions[currentAuctionID].endTime<block.timestamp,"This Auction already ended.");
require(NFTsMinted == true, "NFTs shoud be minted first.");
auctions[currentAuctionID].startTime=block.timestamp;
auctions[currentAuctionID].endTime=block.timestamp + 10 minutes;
auctions[currentAuctionID].tokenID=tokenID;
currentTokenAuctionMapping[tokenID]=currentAuctionID;
emit AuctionCreated(
currentAuctionID,
tokenID,
auctions[currentAuctionID].startTime,
auctions[currentAuctionID].endTime
);
_auctionIDs.increment();
return currentAuctionID;
}
function submitBid(uint tokenID) payable public{
uint currentAuctionID=currentTokenAuctionMapping[tokenID];
require(auctions[currentAuctionID].tokenID==tokenID,"Invalid Token ID");
require(auctions[currentAuctionID].endTime>block.timestamp,"Auction for the token has ended");
uint currentBid = msg.value;
uint previousBid= biddings[currentAuctionID][msg.sender];
require(
auctions[tokenID].highestBid<currentBid
,"Bid Amount should be higher than the highest Bid");
if(previousBid>0){payable(msg.sender).transfer(previousBid);}
biddings[currentAuctionID][msg.sender]=currentBid;
auctions[currentAuctionID].highestBid=currentBid;
auctions[currentAuctionID].highestBidder=msg.sender;
emit BidSubmitted(
currentAuctionID,
tokenID,
currentBid,
msg.sender
);
}
function mintTenNFTs() public onlyOwner {
for (uint i = 0; i < 10; i++) {
_mintSingleNFT();
}
NFTsMinted = true;
emit NFTsWereMinted();
}
function _baseURI() internal view virtual override returns (string memory) {
return baseTokenURI;
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
baseTokenURI = _baseTokenURI;
}
function mintNFTs(uint _count) public payable {
for (uint i = 0; i < _count; i++) {
_mintSingleNFT();
}
}
function _mintSingleNFT() private {
uint newTokenID = _tokenIds.current();
_safeMint(msg.sender, newTokenID);
_tokenIds.increment();
}
function getHighestBid(uint tokenID) public view returns (uint highestBid) {
uint currentAuctionID=currentTokenAuctionMapping[tokenID];
return auctions[currentAuctionID].highestBid;
}
function getHighestBidder(uint tokenID) public view returns (address highestBidder) {
uint currentAuctionID=currentTokenAuctionMapping[tokenID];
return auctions[currentAuctionID].highestBidder;
}
function withdrawNFT(uint tokenID) public{
uint currentAuctionID=currentTokenAuctionMapping[tokenID];
//require(auctions[currentAuctionID].endTime<block.timestamp,"Auction is still ongoing");
if(auctions[currentAuctionID].highestBidder==msg.sender){
_transfer(owner(), msg.sender, auctions[currentAuctionID].tokenID);
emit BidTokenClaimed(
currentAuctionID,
auctions[currentAuctionID].tokenID,
msg.sender
);
}
}
function withdrawLastBid(uint tokenID) public{
uint currentAuctionID=currentTokenAuctionMapping[tokenID];
require(auctions[currentAuctionID].highestBidder!=msg.sender, "You won the auction and cannot take your bid back!");
uint previousBid= biddings[currentAuctionID][msg.sender];
biddings[currentAuctionID][msg.sender] = 0;
if(previousBid>0){payable(msg.sender).transfer(previousBid);}
}
function tokensOfOwner(address _owner) external view returns (uint[] memory) {
uint tokenCount = balanceOf(_owner);
uint[] memory tokensId = new uint256[](tokenCount);
for (uint i = 0; i < tokenCount; i++) {
tokensId[i] = tokenOfOwnerByIndex(_owner, i);
}
return tokensId;
}
function endAuction(uint tokenID) public payable onlyOwner {
uint currentAuctionID=currentTokenAuctionMapping[tokenID];
//require(auctions[currentAuctionID].endTime<block.timestamp,"Auction is still ongoing");
require(auctions[currentAuctionID].highestBid > 0, "No bid left to withdraw");
(bool success, ) = (msg.sender).call{value: auctions[currentAuctionID].highestBid}("");
require(success, "Transfer failed.");
emit AuctionEnded(currentAuctionID, tokenID);
}
function withdraw() public payable onlyOwner {
uint balance = address(this).balance;
require(balance > 0, "No ether left to withdraw");
(bool success, ) = (msg.sender).call{value: balance}("");
require(success, "Transfer failed.");
}
} | require(auctions[currentAuctionID].endTime<block.timestamp,"Auction is still ongoing"); | function withdrawNFT(uint tokenID) public{
uint currentAuctionID=currentTokenAuctionMapping[tokenID];
if(auctions[currentAuctionID].highestBidder==msg.sender){
_transfer(owner(), msg.sender, auctions[currentAuctionID].tokenID);
emit BidTokenClaimed(
currentAuctionID,
auctions[currentAuctionID].tokenID,
msg.sender
);
}
}
| 12,723,950 | [
1,
6528,
12,
69,
4062,
87,
63,
2972,
37,
4062,
734,
8009,
409,
950,
32,
2629,
18,
5508,
10837,
37,
4062,
353,
4859,
30542,
8863,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
598,
9446,
50,
4464,
12,
11890,
1147,
734,
13,
1071,
95,
203,
3639,
203,
3639,
2254,
783,
37,
4062,
734,
33,
2972,
1345,
37,
4062,
3233,
63,
2316,
734,
15533,
203,
203,
3639,
309,
12,
69,
4062,
87,
63,
2972,
37,
4062,
734,
8009,
8766,
395,
17763,
765,
631,
3576,
18,
15330,
15329,
203,
5411,
389,
13866,
12,
8443,
9334,
1234,
18,
15330,
16,
279,
4062,
87,
63,
2972,
37,
4062,
734,
8009,
2316,
734,
1769,
203,
5411,
3626,
605,
350,
1345,
9762,
329,
12,
203,
7734,
783,
37,
4062,
734,
16,
203,
7734,
279,
4062,
87,
63,
2972,
37,
4062,
734,
8009,
2316,
734,
16,
203,
7734,
1234,
18,
15330,
203,
5411,
11272,
203,
3639,
289,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/3/0x0Ec000775A41113E822AC30AC46979B8F2911cE0/sources/CrosschainLoans.sol | * @notice Accept borrower's repayment of principal @param _loanId The ID of the loan @param _secretB1 Lender's secret B1/ | {
require(
sha256(abi.encodePacked(_secretB1)) ==
loans[_loanId].secretHashB1 ||
sha256(abi.encodePacked(_secretB1)) ==
loans[_loanId].secretHashAutoB1,
"CrosschainLoans/invalid-secret-B1"
);
require(
now <= loans[_loanId].acceptExpiration,
"CrosschainLoans/accept-period-expired"
);
require(
loans[_loanId].state == State.Repaid,
"CrosschainLoans/loan-not-repaid"
);
loans[_loanId].state = State.Closed;
loans[_loanId].secretB1 = _secretB1;
uint256 repayment =
loans[_loanId].principal.add(loans[_loanId].interest);
require(
loans[_loanId].token.transfer(loans[_loanId].lender, repayment),
"CrosschainLoans/token-transfer-failed"
);
emit LoanRepaymentAccepted(_loanId, repayment, loans[_loanId].state);
}
| 5,337,802 | [
1,
5933,
29759,
264,
1807,
2071,
2955,
434,
8897,
225,
389,
383,
304,
548,
1021,
1599,
434,
326,
28183,
225,
389,
5875,
38,
21,
511,
2345,
1807,
4001,
605,
21,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
288,
203,
3639,
2583,
12,
203,
5411,
6056,
5034,
12,
21457,
18,
3015,
4420,
329,
24899,
5875,
38,
21,
3719,
422,
203,
7734,
437,
634,
63,
67,
383,
304,
548,
8009,
5875,
2310,
38,
21,
747,
203,
7734,
6056,
5034,
12,
21457,
18,
3015,
4420,
329,
24899,
5875,
38,
21,
3719,
422,
203,
7734,
437,
634,
63,
67,
383,
304,
548,
8009,
5875,
2310,
4965,
38,
21,
16,
203,
5411,
315,
13941,
5639,
1504,
634,
19,
5387,
17,
5875,
17,
38,
21,
6,
203,
3639,
11272,
203,
3639,
2583,
12,
203,
5411,
2037,
1648,
437,
634,
63,
67,
383,
304,
548,
8009,
9436,
12028,
16,
203,
5411,
315,
13941,
5639,
1504,
634,
19,
9436,
17,
6908,
17,
15820,
6,
203,
3639,
11272,
203,
3639,
2583,
12,
203,
5411,
437,
634,
63,
67,
383,
304,
548,
8009,
2019,
422,
3287,
18,
426,
29434,
16,
203,
5411,
315,
13941,
5639,
1504,
634,
19,
383,
304,
17,
902,
17,
266,
29434,
6,
203,
3639,
11272,
203,
203,
3639,
437,
634,
63,
67,
383,
304,
548,
8009,
2019,
273,
3287,
18,
7395,
31,
203,
3639,
437,
634,
63,
67,
383,
304,
548,
8009,
5875,
38,
21,
273,
389,
5875,
38,
21,
31,
203,
203,
3639,
2254,
5034,
2071,
2955,
273,
203,
5411,
437,
634,
63,
67,
383,
304,
548,
8009,
26138,
18,
1289,
12,
383,
634,
63,
67,
383,
304,
548,
8009,
2761,
395,
1769,
203,
3639,
2583,
12,
203,
5411,
437,
634,
63,
67,
383,
304,
548,
8009,
2316,
18,
13866,
12,
383,
634,
63,
67,
2
] |
./full_match/83/0x2Bbf3CF2125d1F876004d081C342DFA1D599C3b2/sources/contracts/FlashLoan.sol | amount and swap fee | amountIn = (amountIn * 10000) / (10000 - getFee(10000, st));
| 9,563,630 | [
1,
8949,
471,
7720,
14036,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
3844,
382,
273,
261,
8949,
382,
380,
12619,
13,
342,
261,
23899,
300,
2812,
1340,
12,
23899,
16,
384,
10019,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
/*
This is the contract for Smart City Coin Test Net(SCCTN)
Smart City Coin Test Net(SCCTN) is utility token designed to be used as prepayment and payment in Smart City Shop.
Smart City Coin Test Net(SCCTN) is utility token designed also to be proof of membership in Smart City Club.
Token implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
Smart City Coin Test Net is as the name implies Test Network - it was deployed in order to test functionalities, options, user interface, liquidity, price fluctuation, type of users,
market research and get first-hand feedback from all involved. We ask all users to be aware of test nature of the token - have patience and preferably
report all errors, opinions, shortcomings to our email address [email protected]. Ask for bounty program for reporting shortcomings and improvement of functionalities.
Smart City Coin Test Network is life real-world test with the goal to gather inputs for the Smart City Coin project.
Smart City Coin Test Network is intended to be used by a skilled professional that understand and accept technology risk involved.
Smart City Coin Test Net and Smart City Shop are operated by Smart City AG.
Smart City AG does not assume any liability for damages or losses occurred due to the usage of SCCTN, since as name implied this is test Network design to test technology and its behavior in the real world.
You can find all about the project on http://www.smartcitycointest.net
You can use your coins in https://www.smartcityshop.net/
You can contact us at [email protected]
*/
pragma solidity ^0.4.24;
contract Token {
/// return total amount of tokens
function totalSupply() public pure returns (uint256) {}
/// param _owner The address from which the balance will be retrieved
/// return The balance
function balanceOf(address) public payable returns (uint256) {}
/// notice send `_value` token to `_to` from `msg.sender`
/// param _to The address of the recipient
/// param _value The amount of token to be transferred
/// return Whether the transfer was successful or not
function transfer(address , uint256 ) public payable returns (bool) {}
/// notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// param _from The address of the sender
/// param _to The address of the recipient
/// param _value The amount of token to be transferred
/// return Whether the transfer was successful or not
function transferFrom(address , address , uint256 ) public payable returns (bool ) {}
/// notice `msg.sender` approves `_addr` to spend `_value` tokens
/// param _spender The address of the account able to transfer the tokens
/// param _value The amount of wei to be approved for transfer
/// return Whether the approval was successful or not
function approve(address , uint256 ) public payable returns (bool ) {}
/// param _owner The address of the account owning tokens
/// param _spender The address of the account able to transfer the tokens
/// return Amount of remaining tokens allowed to spent
function allowance(address , address ) public payable returns (uint256 ) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/*
This implements implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
.*/
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public payable returns (bool ) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) public payable returns (bool ) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) public payable returns (uint256 ) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public payable returns (bool ) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public payable returns (uint256 a ) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
/*
This Token Contract implements the standard token functionality (https://github.com/ethereum/EIPs/issues/20) as well as the following OPTIONAL extras intended for use by humans.
This Token will be deployed, and then used by humans - members of Smart City Community - as an utility token as a prepayment for services and Smart House Hardware in SmartCityShop - www.smartcityshop.net .
This token specify
1) Initial Finite Supply (upon creation one specifies how much is minted).
2) In the absence of a token registry: Optional Decimal, Symbol & Name.
3) Optional approveAndCall() functionality to notify a contract if an approval() has occurred.
.*/
contract SmartCityCoinTestNet is StandardToken {
function () public {
//if ether is sent to this address, send it back.
revert();
}
/* Public variables of the token */
/*
NOTE:
We've inlcuded the following variables as OPTIONAL vanities.
They in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
string public symbol; //An identifier: eg SBX
string public version = 'H0.1'; //human 0.1 standard. Just an arbitrary versioning scheme.
constructor (
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) public {
balances[msg.sender] = _initialAmount; // Give the creator all initial tokens
totalSupply = _initialAmount; // Update total supply
name = _tokenName; // Set the name for display purposes
decimals = _decimalUnits; // Amount of decimals for display purposes
symbol = _tokenSymbol; // Set the symbol for display purposes
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public payable returns (bool ) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
//it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
if(!_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { revert(); }
return true;
}
} | param _owner The address from which the balance will be retrieved return The balance | function balanceOf(address) public payable returns (uint256) {}
| 5,473,544 | [
1,
891,
389,
8443,
1021,
1758,
628,
1492,
326,
11013,
903,
506,
10295,
327,
1021,
11013,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
11013,
951,
12,
2867,
13,
1071,
8843,
429,
1135,
261,
11890,
5034,
13,
2618,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
// Degen'$ Farm: Collectible NFT game (https://degens.farm)
pragma solidity ^0.7.4;
pragma experimental ABIEncoderV2;
import "OpenZeppelin/[email protected]/contracts/token/ERC20/IERC20.sol";
import "OpenZeppelin/[email protected]/contracts/token/ERC1155/IERC1155.sol";
import "OpenZeppelin/[email protected]/contracts/token/ERC1155/ERC1155Receiver.sol";
import "OpenZeppelin/[email protected]/contracts/token/ERC721/IERC721.sol";
import "OpenZeppelin/[email protected]/contracts/access/Ownable.sol";
interface IEggs is IERC721 {
function mint(address to, uint256 tokenId) external;
function burn(uint256 tokenId) external;
function getUsersTokens(address _owner) external view returns (uint256[] memory);
}
interface ICreatures is IERC721 {
function mint(
address to,
uint256 tokenId,
uint8 _animalType,
uint8 _rarity,
uint32 index
) external;
function getTypeAndRarity(uint256 _tokenId) external view returns(uint8, uint8);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
interface ILand is IERC721 {
function mint(
address to,
uint256 tokenId,
uint randomSeed
) external;
function burn(uint256 tokenId) external;
}
interface IDung is IERC20 {
function mint(
address to,
uint256 amount
) external;
}
interface IInventory is IERC1155 {
function getToolBoost(uint8 _item) external view returns (uint16);
}
interface IAmuletPriceProvider {
function getLastPrice(address _amulet) external view returns (uint256);
}
interface IOperatorManage {
function addOperator(address _newOperator) external;
function removeOperator(address _oldOperator) external;
function withdrawERC20(IERC20 _tokenContract, address _admin) external;
function setSigner(address _newSigner) external;
}
abstract contract DegenFarmBase is ERC1155Receiver, Ownable {
enum AnimalType {
Cow, Horse, Rabbit, Chicken, Pig, Cat, Dog, Goose, Goat, Sheep,
Snake, Fish, Frog, Worm, Lama, Mouse, Camel, Donkey, Bee, Duck,
GenesisEgg // 20
}
enum Rarity {
Normie, // 0
Chad, // 1
Degen, // 2
Unique // 3
}
enum Result {Fail, Dung, Chad, Degen}
// External contract addresses used with this farm
struct AddressRegistry {
address land;
address creatures;
address inventory;
address bagstoken;
address dungtoken;
}
// Degens Farm data for creature type
struct CreaturesCount {
uint16 totalNormie;
uint16 leftNormie;
uint16 totalChad;
uint16 leftChadToDiscover;
uint16 totalDegen;
uint16 leftDegenToDiscover;
uint16 chadFarmAttempts;
uint16 degenFarmAttempts;
}
// Land count record
struct LandCount {
uint16 total;
uint16 left;
}
// Record represent one farming act
struct FarmRecord {
uint256 creatureId;
uint256 landId;
uint256 harvestTime;
uint256 amuletsPrice1;
uint256 amuletsPrice2;
Result harvest;
uint256 harvestId; // new NFT tokenId
bool[COMMON_AMULET_COUNT] commonAmuletInitialHold;
}
// Bonus for better harvest
struct Bonus {
uint256 commonAmuletHold; // common amulet hold
uint256 creatureAmuletBullTrend;
uint256 inventoryHold;
uint256 creatureAmuletBalance;
}
uint8 constant public CREATURE_TYPE_COUNT_MAX = 20; //how much creatures types may be used
// Creature probability multiplier, scaled with 100. 3.00 - 300, 3.05 - 305 etc
uint32 constant public CREATURE_P_MULT = 230;
uint16 public MAX_ALL_NORMIES = getCreatureTypeCount() * getNormieCountInType();
uint256 constant public NFT_ID_MULTIPLIER = 10000; //must be set more then all Normies count
uint256 constant public FARM_DUNG_AMOUNT = 250e33; //per one harvest
uint256 constant public BONUS_POINTS_AMULET_HOLD = 10;
uint256 constant public COMMON_AMULET_COUNT = 2;
uint256 constant public TOOL_TYPE_COUNT = 6;
// Common Amulet addresses
address[COMMON_AMULET_COUNT] public COMMON_AMULETS = [
0x126c121f99e1E211dF2e5f8De2d96Fa36647c855, // $DEGEN token
0xa0246c9032bC3A600820415aE600c6388619A14D // $FARM token
];
bool public REVEAL_ENABLED = false;
bool public FARMING_ENABLED = false;
address public priceProvider;
IEggs public eggs;
address[CREATURE_TYPE_COUNT_MAX] public amulets; // amulets by creature type
AddressRegistry public farm;
LandCount public landCount;
mapping(address => uint256) public maxAmuletBalances;
// mapping from user to his(her) staked tools
// Index of uint256[6] represent tool NFT itemID
mapping(address => uint256[TOOL_TYPE_COUNT]) public userStakedTools;
uint16 public allNormiesesLeft;
CreaturesCount[CREATURE_TYPE_COUNT_MAX] public creaturesBorn;
FarmRecord[] public farming;
mapping(uint => uint) public parents;
event Reveal(address _farmer, uint256 indexed _tokenId, bool _isCreature, uint8 _animalType);
event Harvest(
uint256 indexed _eggId,
address farmer,
uint8 result,
uint256 baseChance,
uint256 commonAmuletHold,
uint256 amuletBullTrend,
uint256 inventoryHold,
uint256 amuletMaxBalance,
uint256 resultChance
);
event Stake(address owner, uint8 innventory);
event UnStake(address owner, uint8 innventory);
constructor (
address _land,
address _creatures,
address _inventory,
address _bagstoken,
address _dungtoken,
IEggs _eggs
)
{
farm.land = _land;
farm.creatures = _creatures;
farm.inventory = _inventory;
farm.bagstoken = _bagstoken;
farm.dungtoken = _dungtoken;
// Index of creaturesBorn in this initial setting
// must NOT exceed CREATURE_TYPE_COUNT
for (uint i = 0; i < getCreatureTypeCount(); i++) {
creaturesBorn[i] = CreaturesCount(
getNormieCountInType(), // totalNormie;
getNormieCountInType(), // leftNormie;
getChadCountInType(), // totalChad;
getChadCountInType(), // leftChadToDiscover;
1, // totalDegen;
1, // leftDegenToDiscover;
0, // chadFarmAttempts;
0); // degenFarmAttempts;
}
landCount = LandCount(getMaxLands(), getMaxLands());
allNormiesesLeft = MAX_ALL_NORMIES;
eggs = _eggs;
}
function reveal(uint count) external {
require(_isRevelEnabled(), "Please wait for reveal enabled.");
require(count > 0, "Count must be positive");
require(count <= 8, "Count must less than 9"); // random limit
require(
IERC20(farm.bagstoken).allowance(msg.sender, address(this)) >= count*1,
"Please approve your BAGS token to this contract."
);
require(
IERC20(farm.bagstoken).transferFrom(msg.sender, address(this), count*1)
);
uint randomSeed = uint(keccak256(abi.encodePacked(block.timestamp, msg.sender)));
// random seed for 8 reveals (8x32=256)
for (uint i = 0; i < count; i++) {
_reveal(randomSeed);
randomSeed = randomSeed / 0x100000000; // shift right 32 bits
}
}
/**
* @dev Start farming process. New NFT - Egg will minted for user
* @param _creatureId - NFT tokenId, caller must be owner of this token
* @param _landId -- NFT tokenId, caller must be owner of this token
*/
function farmDeploy(uint256 _creatureId, uint256 _landId) external {
require(FARMING_ENABLED == true, "Chief Farmer not enable yet");
require(ICreatures(farm.creatures).ownerOf(_creatureId) == msg.sender,
"Need to be Creature Owner"
);
require(ILand(farm.land).ownerOf(_landId) == msg.sender,
"Need to be Land Owner"
);
(uint8 crType, uint8 crRarity) = ICreatures(farm.creatures).getTypeAndRarity(_creatureId);
require((DegenFarmBase.Rarity)(crRarity) == Rarity.Normie ||
(DegenFarmBase.Rarity)(crRarity) == Rarity.Chad,
"Can farm only Normie and Chad");
// Check that farming available yet
if (crRarity == 0) {
require(creaturesBorn[crType].leftChadToDiscover > 0, "No more chads left");
} else {
require(creaturesBorn[crType].leftDegenToDiscover > 0, "No more Degen left");
}
// Save deploy record
farming.push(
FarmRecord({
creatureId: _creatureId,
landId: _landId,
harvestTime: block.timestamp + getFarmingDuration(),
amuletsPrice1: _getExistingAmuletsPrices(amulets[crType]),
amuletsPrice2: 0,
harvest: Result.Fail,
harvestId: 0,
commonAmuletInitialHold: _getCommonAmuletsHoldState(msg.sender) //save initial hold state
})
);
// Let's mint Egg.
eggs.mint(
msg.sender, // farmer
farming.length - 1 // tokenId
);
// STAKE LAND and Creatures
ILand(farm.land).transferFrom(msg.sender, address(this), _landId);
ICreatures(farm.creatures).transferFrom(msg.sender, address(this), _creatureId);
}
/**
* @dev Finish farming process. Egg NFT will be burn
* @param _deployId - NFT tokenId, caller must be owner of this token
*/
function harvest(uint256 _deployId) external {
require(eggs.ownerOf(_deployId) == msg.sender, "This is NOT YOUR EGG");
FarmRecord storage f = farming[_deployId];
require(f.harvestTime <= block.timestamp, "To early for harvest");
// Lets Calculate Dung/CHAD-DEGEN chance
Result farmingResult;
Bonus memory bonus;
// 1. BaseChance
(uint8 crType, uint8 crRarity) = ICreatures(farm.creatures).getTypeAndRarity(
f.creatureId
);
uint256 baseChance;
if (crRarity == 0) {
// Try farm CHAD. So if there is no CHADs any more we must return assets
if (creaturesBorn[crType].leftChadToDiscover == 0) {
_endFarming(_deployId, Result.Fail);
return;
}
baseChance = 100 * creaturesBorn[crType].totalChad / creaturesBorn[crType].totalNormie; // by default 20%
// Decrease appropriate farm ATTEMPTS COUNT
creaturesBorn[crType].chadFarmAttempts += 1;
} else {
// Try farm DEGEN. So if there is no DEGENSs any more we must return assets
if (creaturesBorn[crType].leftDegenToDiscover == 0) {
_endFarming(_deployId, Result.Fail);
return;
}
baseChance = 100 * creaturesBorn[crType].totalDegen / creaturesBorn[crType].totalChad; // by default 5%
// Decrease appropriate farm ATTEMPTS COUNT
creaturesBorn[crType].degenFarmAttempts += 1;
}
//////////////////////////////////////////////
// 2. Bonus for common amulet token ***HOLD*** - commonAmuletHold
//////////////////////////////////////////////
// Get current hold stae
for (uint8 i = 0; i < COMMON_AMULETS.length; i ++){
if (f.commonAmuletInitialHold[i] && _getCommonAmuletsHoldState(msg.sender)[i]) {
bonus.commonAmuletHold = BONUS_POINTS_AMULET_HOLD;
}
}
//////////////////////////////////////////////
// 3. Bonus for creatures amulets BULLs trend - creatureAmuletBullTrend
// 4. Bonus for creatures amulets balance - creatureAmuletBalance
//////////////////////////////////////////////
uint256 prices2 = 0;
prices2 = _getExistingAmuletsPrices(amulets[crType]);
if (f.amuletsPrice1 > 0 && prices2 > 0 && prices2 > f.amuletsPrice1){
bonus.creatureAmuletBullTrend =
(prices2 - f.amuletsPrice1) * 100 / f.amuletsPrice1;
}
//Lets check max Balance, because
//bonus.amuletHold = userAmuletBalance/maxAmuletBalances*BONUS_POINTS_AMULET_HOLD
_checkAndSaveMaxAmuletPrice(amulets[crType]);
if (maxAmuletBalances[amulets[crType]] > 0) {
bonus.creatureAmuletBalance =
IERC20(amulets[crType]).balanceOf(msg.sender) * 100 //100 used for scale
/ maxAmuletBalances[amulets[crType]] * BONUS_POINTS_AMULET_HOLD /100;
}
f.amuletsPrice2 = prices2;
//////////////////////////////////////////////
//5. Bonus for inventory
//////////////////////////////////////////////
bonus.inventoryHold = 0;
if (userStakedTools[msg.sender].length > 0) {
for (uint8 i=0; i < userStakedTools[msg.sender].length; i++) {
if (userStakedTools[msg.sender][i] > 0) {
bonus.inventoryHold = bonus.inventoryHold + IInventory(farm.inventory).getToolBoost(i);
}
}
}
//////////////////////////////////////////////
uint256 allBonus = bonus.commonAmuletHold
+ bonus.creatureAmuletBullTrend
+ bonus.creatureAmuletBalance
+ bonus.inventoryHold;
if (allBonus > 100) {
allBonus = 100; // limit bonus to 100%
}
uint32[] memory choiceWeight = new uint32[](2);
choiceWeight[0] = uint32(baseChance * (100 + allBonus)); // chance of born new chad/degen
choiceWeight[1] = uint32(10000 - choiceWeight[0]); // receive DUNG
if (_getWeightedChoice(choiceWeight) == 0) {
f.harvestId = (crRarity + 1) * NFT_ID_MULTIPLIER + _deployId;
// Mint new chad/degen
uint32 index;
// Decrease appropriate CREATURE COUNT
if (crRarity + 1 == uint8(Rarity.Chad)) {
index = creaturesBorn[crType].totalChad - creaturesBorn[crType].leftChadToDiscover + 1;
creaturesBorn[crType].leftChadToDiscover -= 1;
farmingResult = Result.Chad;
} else if (crRarity + 1 == uint8(Rarity.Degen)) {
index = creaturesBorn[crType].totalDegen - creaturesBorn[crType].leftDegenToDiscover + 1;
creaturesBorn[crType].leftDegenToDiscover -= 1;
farmingResult = Result.Degen;
}
uint newCreatureId = (crRarity + 1) * NFT_ID_MULTIPLIER + _deployId;
ICreatures(farm.creatures).mint(
msg.sender,
newCreatureId, // new iD
crType, // AnimalType
crRarity + 1,
index // index
);
parents[newCreatureId] = f.creatureId;
} else {
// Mint new dung
IDung(farm.dungtoken).mint(msg.sender, FARM_DUNG_AMOUNT);
farmingResult = Result.Dung;
}
// BURN Land
ILand(farm.land).burn(f.landId);
_endFarming(_deployId, farmingResult);
emit Harvest(
_deployId,
msg.sender,
uint8(farmingResult),
baseChance,
bonus.commonAmuletHold,
bonus.creatureAmuletBullTrend,
bonus.inventoryHold,
bonus.creatureAmuletBalance,
choiceWeight[0]
);
}
/**
* @dev Stake one inventory item
* @param _itemId - NFT tokenId, caller must be owner of this token
*/
function stakeOneTool(uint8 _itemId) external {
_stakeOneTool(_itemId);
emit Stake(msg.sender, _itemId);
}
/**
* @dev UnStake one inventory item
* @param _itemId - NFT tokenId
*/
function unstakeOneTool(uint8 _itemId) external {
_unstakeOneTool(_itemId);
emit UnStake(msg.sender, _itemId);
}
/////////////////////////////////////////////////////
//// Admin functions ///////
/////////////////////////////////////////////////////
function setOneCommonAmulet(uint8 _index, address _token) external onlyOwner {
COMMON_AMULETS[_index] = _token;
}
function setAmuletForOneCreature(uint8 _index, address _token) external onlyOwner {
amulets[_index] = _token;
}
function setAmulets(address[] calldata _tokens) external onlyOwner {
for (uint i = 0; i < _tokens.length; i++) {
amulets[i] = _tokens[i];
}
}
function setPriceProvider(address _priceProvider) external onlyOwner {
priceProvider = _priceProvider;
}
function enableReveal(bool _isEnabled) external onlyOwner {
REVEAL_ENABLED = _isEnabled;
}
function enableFarming(bool _isEnabled) external onlyOwner {
FARMING_ENABLED = _isEnabled;
}
////////////////////////////////////////
/// Proxy for NFT Operators mamnage //
////////////////////////////////////////
function addOperator(address _contract, address newOperator) external onlyOwner {
IOperatorManage(_contract).addOperator(newOperator);
}
function removeOperator(address _contract, address oldOperator) external onlyOwner {
IOperatorManage(_contract).removeOperator(oldOperator);
}
function reclaimToken(address _contract, IERC20 anyTokens, address _admin) external onlyOwner {
IOperatorManage(_contract).withdrawERC20(anyTokens, _admin);
}
function setSigner(address _contract, address _newSigner) external onlyOwner {
IOperatorManage(_contract).setSigner(_newSigner);
}
////////////////////////////////////////////////////////
function getCreatureAmulets(uint8 _creatureType) external view returns (address) {
return _getCreatureAmulets(_creatureType);
}
function _getCreatureAmulets(uint8 _creatureType) internal view returns (address) {
return amulets[_creatureType];
}
function getCreatureStat(uint8 _creatureType)
external
view
returns (
uint16,
uint16,
uint16,
uint16,
uint16,
uint16,
uint16,
uint16
)
{
CreaturesCount storage stat = creaturesBorn[_creatureType];
return (
stat.totalNormie,
stat.leftNormie,
stat.totalChad,
stat.leftChadToDiscover,
stat.totalDegen,
stat.leftDegenToDiscover,
stat.chadFarmAttempts,
stat.degenFarmAttempts
);
}
function getWeightedChoice(uint32[] memory _weights) external view returns (uint8){
return _getWeightedChoice(_weights);
}
function _getWeightedChoice(uint32[] memory _weights) internal view returns (uint8){
uint randomSeed = uint(keccak256(abi.encodePacked(block.timestamp, msg.sender)));
return _getWeightedChoice2(_weights, randomSeed);
}
function getFarmingById(uint256 _farmingId) external view returns (FarmRecord memory) {
return farming[_farmingId];
}
function getOneAmuletPrice(address _token) external view returns (uint256) {
return _getOneAmuletPrice(_token);
}
///////////////////////////////////////////////
/// Internals ///////
///////////////////////////////////////////////
/**
* @dev Save farming results in storage and mint
* appropriate token (NFT, ERC20 or None)
*/
function _endFarming(uint256 _deployId, Result _res) internal {
FarmRecord storage f = farming[_deployId];
f.harvest = _res;
// unstake creature
ICreatures(farm.creatures).transferFrom(address(this), msg.sender, f.creatureId);
eggs.burn(_deployId); // Burn EGG
if (_res == Result.Fail) {
//unstake land (if staked)
if (ILand(farm.land).ownerOf(f.landId) == address(this)){
ILand(farm.land).transferFrom(address(this), msg.sender, f.landId);
}
emit Harvest(
_deployId,
msg.sender,
uint8(_res),
0, //baseChance
0, //bonus.commonAmuletHold
0, //bonus.creatureAmuletBullTrend,
0, //bonus.inventoryHold
0, // bonus.creatureAmuletBalance
0
);
}
}
function _stakeOneTool(uint8 _itemId) internal {
require(IInventory(farm.inventory).balanceOf(msg.sender, _itemId) >= 1,
"You must own this tool for stake!"
);
// Before stake we need two checks.
// 1. Removed
// 2. Cant`t stake one tool more than one item
require(userStakedTools[msg.sender][_itemId] == 0, "Tool is already staked");
// stake
IInventory(farm.inventory).safeTransferFrom(
msg.sender,
address(this),
_itemId,
1,
bytes('0')
);
userStakedTools[msg.sender][_itemId] = block.timestamp;
}
function _unstakeOneTool(uint8 _itemId) internal {
require(userStakedTools[msg.sender][_itemId] > 0, "This tool is not staked yet");
require(block.timestamp - userStakedTools[msg.sender][_itemId] >= getToolUnstakeDelay(),
"Cant unstake earlier than a week"
);
userStakedTools[msg.sender][_itemId] = 0;
IInventory(farm.inventory).safeTransferFrom(
address(this),
msg.sender,
_itemId,
1,
bytes('0')
);
}
function _checkAndSaveMaxAmuletPrice(address _amulet) internal {
if (IERC20(_amulet).balanceOf(msg.sender)
> maxAmuletBalances[_amulet]
)
{
maxAmuletBalances[_amulet]
= IERC20(_amulet).balanceOf(msg.sender);
}
}
function _getCommonAmuletsHoldState(address _farmer) internal view returns (bool[COMMON_AMULET_COUNT] memory) {
// If token balance =0 - set false
bool[COMMON_AMULET_COUNT] memory res;
for (uint8 i = 0; i < COMMON_AMULETS.length; i++){
if (IERC20(COMMON_AMULETS[i]).balanceOf(_farmer) > 0){
res[i] = true;
} else {
// Set to zero if token balance is 0
res[i] = false;
}
}
return res;
}
function _getExistingAmuletsPrices(address _token)
internal
view
returns (uint256)
{
if (IERC20(_token).balanceOf(msg.sender) > 0){
return _getOneAmuletPrice(_token);
} else {
// Set to zero if token balance is 0
return 0;
}
}
function _getOneAmuletPrice(address _token) internal view returns (uint256) {
return IAmuletPriceProvider(priceProvider).getLastPrice(_token);
}
function _isRevelEnabled() internal view returns (bool) {
return REVEAL_ENABLED;
}
function _reveal(uint randomSeed) internal {
require ((landCount.left + allNormiesesLeft) > 0, "Sorry, no more reveal!");
//1. Lets choose Land OR Creature, %
//So we have two possible results. 1 - Land, 0 - Creature.
// sum of weights = 100, lets define weigth for Creature
uint32[] memory choiceWeight = new uint32[](2);
choiceWeight[0] = uint32(allNormiesesLeft) * CREATURE_P_MULT;
choiceWeight[1] = uint32(landCount.left) * 100;
uint8 choice = uint8(_getWeightedChoice2(choiceWeight, randomSeed));
randomSeed /= 0x10000; // shift right 16 bits
//Check that choice can be executed
if (choice != 0 && landCount.left == 0) {
//There are no more Lands. So we need change choice
choice = 0;
}
if (choice == 0) { // create creature
uint32[] memory choiceWeight0 = new uint32[](getCreatureTypeCount());
//2. Ok, Creature will be born. But what kind of?
for (uint8 i = 0; i < getCreatureTypeCount(); i ++) {
choiceWeight0[i] = uint32(creaturesBorn[i].leftNormie);
}
choice = uint8(_getWeightedChoice2(choiceWeight0, randomSeed));
ICreatures(farm.creatures).mint(
msg.sender,
MAX_ALL_NORMIES - allNormiesesLeft,
choice, //AnimalType
0,
creaturesBorn[choice].totalNormie - creaturesBorn[choice].leftNormie + 1 // index
);
emit Reveal(msg.sender, MAX_ALL_NORMIES - allNormiesesLeft, true, choice);
allNormiesesLeft -= 1;
creaturesBorn[choice].leftNormie -= 1;
} else { // create land
ILand(farm.land).mint(
msg.sender,
getMaxLands() - landCount.left,
randomSeed
);
emit Reveal(msg.sender, getMaxLands() - landCount.left , false, 0);
landCount.left -= 1;
}
}
function _getWeightedChoice2(uint32[] memory _weights, uint randomSeed) internal view returns (uint8){
uint256 sum_of_weights = 0;
for (uint8 index = 0; index < _weights.length; index++) {
sum_of_weights += _weights[index];
}
uint256 rnd = randomSeed % sum_of_weights;
for (uint8 kindex = 0; kindex < _weights.length; kindex++) {
if (rnd < _weights[kindex]) {
return kindex;
}
rnd -= _weights[kindex];
}
return 0;
}
/**
@dev Handles the receipt of a single ERC1155 token type. This function is
called at the end of a `safeTransferFrom` after the balance has been updated.
To accept the transfer, this must return
`bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
(i.e. 0xf23a6e61, or its own function selector).
@param operator The address which initiated the transfer (i.e. msg.sender)
@param from The address which previously owned the token
@param id The ID of the token being transferred
@param value The amount of tokens being transferred
@param data Additional data with no specified format
@return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
*/
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
)
external
override
returns(bytes4)
{
return bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"));
}
/**
@dev Handles the receipt of a multiple ERC1155 token types. This function
is called at the end of a `safeBatchTransferFrom` after the balances have
been updated. To accept the transfer(s), this must return
`bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
(i.e. 0xbc197c81, or its own function selector).
@param operator The address which initiated the batch transfer (i.e. msg.sender)
@param from The address which previously owned the token
@param ids An array containing ids of each token being transferred (order and length must match values array)
@param values An array containing amounts of each token being transferred (order and length must match ids array)
@param data Additional data with no specified format
@return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
*/
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
)
external
override
returns(bytes4)
{
return bytes4(keccak256("onERC1155BatchReceived(address,address,uint256,uint256,bytes)"));
}
function getCreatureTypeCount() virtual internal view returns (uint16);
function getFarmingDuration() virtual internal view returns (uint);
function getToolUnstakeDelay() virtual internal view returns (uint);
function getNormieCountInType() virtual internal view returns (uint16);
function getChadCountInType() virtual internal view returns (uint16);
function getMaxLands() virtual internal view returns (uint16);
function getUsersTokens(address _owner) external view returns (uint256[] memory) {
return eggs.getUsersTokens(_owner);
}
/**
* @dev Returns creatures owned by owner and that can be used for farming.this
* Some creatures types and rarity are limited to farm because all chad/degens
* was already discovered.
* @param _owner - creatures owner
*/
function getFarmingAllowedCreatures(address _owner) external view returns (uint256[] memory) {
uint256 n = ICreatures(farm.creatures).balanceOf(_owner);
uint256[] memory result = new uint256[](n);
uint256 count = 0;
for (uint16 i = 0; i < n; i++) {
uint creatureId = ICreatures(farm.creatures).tokenOfOwnerByIndex(_owner, i);
if (isFarmingAllowedForCreature(creatureId)) {
result[count] = creatureId;
count++;
}
}
uint256[] memory result2 = new uint256[](count);
for (uint16 i = 0; i < count; i++) {
result2[i] = result[i];
}
return result2;
}
function getFarmingAllowedCreaturesWithRarity(address _owner, uint8 wantRarity) external view returns (uint256[] memory) {
uint256 n = ICreatures(farm.creatures).balanceOf(_owner);
uint256[] memory result = new uint256[](n);
uint256 count = 0;
for (uint16 i = 0; i < n; i++) {
uint creatureId = ICreatures(farm.creatures).tokenOfOwnerByIndex(_owner, i);
(uint8 _, uint8 rarity) = ICreatures(farm.creatures).getTypeAndRarity(creatureId);
if (rarity == wantRarity && isFarmingAllowedForCreature(creatureId)) {
result[count] = creatureId;
count++;
}
}
uint256[] memory result2 = new uint256[](count);
for (uint16 i = 0; i < count; i++) {
result2[i] = result[i];
}
return result2;
}
function isFarmingAllowedForCreature(uint creatureId) public view returns (bool) {
(uint8 _type, uint8 rarity) = ICreatures(farm.creatures).getTypeAndRarity(creatureId);
if ((DegenFarmBase.Rarity)(rarity) == Rarity.Normie) {
return creaturesBorn[_type].leftChadToDiscover > 0;
}
if ((DegenFarmBase.Rarity)(rarity) == Rarity.Chad) {
return creaturesBorn[_type].leftDegenToDiscover > 0;
}
return false;
}
}
| limit bonus to 100%
| allBonus = 100; | 894,864 | [
1,
3595,
324,
22889,
358,
2130,
9,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
5411,
777,
38,
22889,
273,
2130,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/1/0x081231339BcC4061e4511d73f1697C021B461aC2/sources/contracts/eslsd/esLSD.sol | * @dev Vest $LSD tokens from $esLSD tokens @param amount Amount of $esLSD to vest/ Case 1: No ongoing vesting Case 2: Ongoing vesting Case 2.1: Ongoing vesting, all vested Case 2.2: Ongoing vesting, partial vested | function vest(uint256 amount) external nonReentrant {
require(amount > 0, "Amount must be greater than 0");
require(amount <= balanceOf(_msgSender()), "Vest amount exceeds balance");
_transfer(_msgSender(), address(this), amount);
VestingInfo storage vestingInfo = userVestings[msg.sender];
uint256 accruedAmount = amount;
uint256 unlocked = 0;
if (vestingInfo.amount == 0) {
}
else {
require(block.timestamp >= vestingInfo.startTime, "Vesting not started");
if (block.timestamp >= vestingInfo.endTime) {
unlocked = vestingInfo.amount;
}
else {
unlocked = vestingInfo.amount.mul(block.timestamp.sub(vestingInfo.startTime)).div(vestingInfo.endTime.sub(vestingInfo.startTime));
accruedAmount = accruedAmount.add(vestingInfo.amount).sub(unlocked);
}
}
if (unlocked > 0) {
lsdToken.safeTransfer(_msgSender(), unlocked);
_burn(address(this), unlocked);
emit Claim(_msgSender(), unlocked);
}
vestingInfo.amount = accruedAmount;
vestingInfo.startTime = block.timestamp;
vestingInfo.endTime = block.timestamp.add(vestingPeriod);
emit Vest(_msgSender(), amount, vestingInfo.amount, vestingPeriod);
}
| 8,406,418 | [
1,
58,
395,
271,
3045,
40,
2430,
628,
271,
281,
3045,
40,
2430,
225,
3844,
16811,
434,
271,
281,
3045,
40,
358,
331,
395,
19,
12605,
404,
30,
2631,
30542,
331,
10100,
12605,
576,
30,
2755,
8162,
331,
10100,
12605,
576,
18,
21,
30,
2755,
8162,
331,
10100,
16,
777,
331,
3149,
12605,
576,
18,
22,
30,
2755,
8162,
331,
10100,
16,
4702,
331,
3149,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
225,
445,
331,
395,
12,
11890,
5034,
3844,
13,
3903,
1661,
426,
8230,
970,
288,
203,
565,
2583,
12,
8949,
405,
374,
16,
315,
6275,
1297,
506,
6802,
2353,
374,
8863,
203,
565,
2583,
12,
8949,
1648,
11013,
951,
24899,
3576,
12021,
1435,
3631,
315,
58,
395,
3844,
14399,
11013,
8863,
203,
203,
565,
389,
13866,
24899,
3576,
12021,
9334,
1758,
12,
2211,
3631,
3844,
1769,
203,
203,
565,
776,
10100,
966,
2502,
331,
10100,
966,
273,
729,
58,
395,
899,
63,
3576,
18,
15330,
15533,
203,
565,
2254,
5034,
4078,
86,
5957,
6275,
273,
3844,
31,
203,
565,
2254,
5034,
25966,
273,
374,
31,
203,
565,
309,
261,
90,
10100,
966,
18,
8949,
422,
374,
13,
288,
203,
203,
565,
289,
203,
565,
469,
288,
203,
1377,
2583,
12,
2629,
18,
5508,
1545,
331,
10100,
966,
18,
1937,
950,
16,
315,
58,
10100,
486,
5746,
8863,
203,
1377,
309,
261,
2629,
18,
5508,
1545,
331,
10100,
966,
18,
409,
950,
13,
288,
203,
3639,
25966,
273,
331,
10100,
966,
18,
8949,
31,
203,
1377,
289,
203,
1377,
469,
288,
203,
3639,
25966,
273,
331,
10100,
966,
18,
8949,
18,
16411,
12,
2629,
18,
5508,
18,
1717,
12,
90,
10100,
966,
18,
1937,
950,
13,
2934,
2892,
12,
90,
10100,
966,
18,
409,
950,
18,
1717,
12,
90,
10100,
966,
18,
1937,
950,
10019,
203,
3639,
4078,
86,
5957,
6275,
273,
4078,
86,
5957,
6275,
18,
1289,
12,
90,
10100,
966,
18,
8949,
2934,
1717,
12,
318,
15091,
1769,
203,
1377,
289,
203,
565,
2
] |
./partial_match/1/0xc2c906149E68e0449321737912a5c85DF103A0fa/sources/DfFinanceCloseCompound.sol | in usd โ max more 1.2 mln USD for 1 eth
| uint80 entryEthPrice; | 16,049,633 | [
1,
267,
584,
72,
225,
163,
227,
246,
943,
1898,
404,
18,
22,
312,
2370,
587,
9903,
364,
404,
13750,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
3639,
2254,
3672,
1241,
41,
451,
5147,
31,
282,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity ^0.4.13;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract AbstractStarbaseToken is ERC20 {
function isFundraiser(address fundraiserAddress) public returns (bool);
function company() public returns (address);
function allocateToCrowdsalePurchaser(address to, uint256 value) public returns (bool);
function allocateToMarketingSupporter(address to, uint256 value) public returns (bool);
}
contract AbstractStarbaseCrowdsale {
function workshop() constant returns (address) {}
function startDate() constant returns (uint256) {}
function endedAt() constant returns (uint256) {}
function isEnded() constant returns (bool);
function totalRaisedAmountInCny() constant returns (uint256);
function numOfPurchasedTokensOnCsBy(address purchaser) constant returns (uint256);
function numOfPurchasedTokensOnEpBy(address purchaser) constant returns (uint256);
}
// @title EarlyPurchase contract - Keep track of purchased amount by Early Purchasers
/// @author Starbase PTE. LTD. - <[email protected]>
contract StarbaseEarlyPurchase {
/*
* Constants
*/
string public constant PURCHASE_AMOUNT_UNIT = 'CNY'; // Chinese Yuan
string public constant PURCHASE_AMOUNT_RATE_REFERENCE = 'http://www.xe.com/currencytables/';
uint256 public constant PURCHASE_AMOUNT_CAP = 9000000;
/*
* Types
*/
struct EarlyPurchase {
address purchaser;
uint256 amount; // CNY based amount
uint256 purchasedAt; // timestamp
}
/*
* External contracts
*/
AbstractStarbaseCrowdsale public starbaseCrowdsale;
/*
* Storage
*/
address public owner;
EarlyPurchase[] public earlyPurchases;
uint256 public earlyPurchaseClosedAt;
/*
* Modifiers
*/
modifier noEther() {
require(msg.value == 0);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyBeforeCrowdsale() {
assert(address(starbaseCrowdsale) == address(0) || starbaseCrowdsale.startDate() == 0);
_;
}
modifier onlyEarlyPurchaseTerm() {
assert(earlyPurchaseClosedAt <= 0);
_;
}
/*
* Contract functions
*/
/**
* @dev Returns early purchased amount by purchaser's address
* @param purchaser Purchaser address
*/
function purchasedAmountBy(address purchaser)
external
constant
noEther
returns (uint256 amount)
{
for (uint256 i; i < earlyPurchases.length; i++) {
if (earlyPurchases[i].purchaser == purchaser) {
amount += earlyPurchases[i].amount;
}
}
}
/**
* @dev Returns total amount of raised funds by Early Purchasers
*/
function totalAmountOfEarlyPurchases()
constant
noEther
public
returns (uint256 totalAmount)
{
for (uint256 i; i < earlyPurchases.length; i++) {
totalAmount += earlyPurchases[i].amount;
}
}
/**
* @dev Returns number of early purchases
*/
function numberOfEarlyPurchases()
external
constant
noEther
returns (uint256)
{
return earlyPurchases.length;
}
/**
* @dev Append an early purchase log
* @param purchaser Purchaser address
* @param amount Purchase amount
* @param purchasedAt Timestamp of purchased date
*/
function appendEarlyPurchase(address purchaser, uint256 amount, uint256 purchasedAt)
external
noEther
onlyOwner
onlyBeforeCrowdsale
onlyEarlyPurchaseTerm
returns (bool)
{
if (amount == 0 ||
totalAmountOfEarlyPurchases() + amount > PURCHASE_AMOUNT_CAP)
{
return false;
}
assert(purchasedAt != 0 || purchasedAt <= now);
earlyPurchases.push(EarlyPurchase(purchaser, amount, purchasedAt));
return true;
}
/**
* @dev Close early purchase term
*/
function closeEarlyPurchase()
external
noEther
onlyOwner
returns (bool)
{
earlyPurchaseClosedAt = now;
}
/**
* @dev Setup function sets external contract's address
* @param starbaseCrowdsaleAddress Token address
*/
function setup(address starbaseCrowdsaleAddress)
external
noEther
onlyOwner
returns (bool)
{
if (address(starbaseCrowdsale) == 0) {
starbaseCrowdsale = AbstractStarbaseCrowdsale(starbaseCrowdsaleAddress);
return true;
}
return false;
}
/**
* @dev Contract constructor function
*/
function StarbaseEarlyPurchase() noEther {
owner = msg.sender;
}
}
/// @title EarlyPurchaseAmendment contract - Amend early purchase records of the original contract
/// @author Starbase PTE. LTD. - <[email protected]>
contract StarbaseEarlyPurchaseAmendment {
/*
* Events
*/
event EarlyPurchaseInvalidated(uint256 epIdx);
event EarlyPurchaseAmended(uint256 epIdx);
/*
* External contracts
*/
AbstractStarbaseCrowdsale public starbaseCrowdsale;
StarbaseEarlyPurchase public starbaseEarlyPurchase;
/*
* Storage
*/
address public owner;
uint256[] public invalidEarlyPurchaseIndexes;
uint256[] public amendedEarlyPurchaseIndexes;
mapping (uint256 => StarbaseEarlyPurchase.EarlyPurchase) public amendedEarlyPurchases;
/*
* Modifiers
*/
modifier noEther() {
require(msg.value == 0);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyBeforeCrowdsale() {
assert(address(starbaseCrowdsale) == address(0) || starbaseCrowdsale.startDate() == 0);
_;
}
modifier onlyEarlyPurchasesLoaded() {
assert(address(starbaseEarlyPurchase) != address(0));
_;
}
/*
* Functions below are compatible with starbaseEarlyPurchase contract
*/
/**
* @dev Returns an early purchase record
* @param earlyPurchaseIndex Index number of an early purchase
*/
function earlyPurchases(uint256 earlyPurchaseIndex)
external
constant
onlyEarlyPurchasesLoaded
returns (address purchaser, uint256 amount, uint256 purchasedAt)
{
return starbaseEarlyPurchase.earlyPurchases(earlyPurchaseIndex);
}
/**
* @dev Returns early purchased amount by purchaser's address
* @param purchaser Purchaser address
*/
function purchasedAmountBy(address purchaser)
external
constant
noEther
returns (uint256 amount)
{
StarbaseEarlyPurchase.EarlyPurchase[] memory normalizedEP =
normalizedEarlyPurchases();
for (uint256 i; i < normalizedEP.length; i++) {
if (normalizedEP[i].purchaser == purchaser) {
amount += normalizedEP[i].amount;
}
}
}
/**
* @dev Returns total amount of raised funds by Early Purchasers
*/
function totalAmountOfEarlyPurchases()
constant
noEther
public
returns (uint256 totalAmount)
{
StarbaseEarlyPurchase.EarlyPurchase[] memory normalizedEP =
normalizedEarlyPurchases();
for (uint256 i; i < normalizedEP.length; i++) {
totalAmount += normalizedEP[i].amount;
}
}
/**
* @dev Returns number of early purchases
*/
function numberOfEarlyPurchases()
external
constant
noEther
returns (uint256)
{
return normalizedEarlyPurchases().length;
}
/**
* @dev Sets up function sets external contract's address
* @param starbaseCrowdsaleAddress Token address
*/
function setup(address starbaseCrowdsaleAddress)
external
noEther
onlyOwner
returns (bool)
{
if (address(starbaseCrowdsale) == 0) {
starbaseCrowdsale = AbstractStarbaseCrowdsale(starbaseCrowdsaleAddress);
return true;
}
return false;
}
/*
* Contract functions unique to StarbaseEarlyPurchaseAmendment
*/
/**
* @dev Invalidate early purchase
* @param earlyPurchaseIndex Index number of the purchase
*/
function invalidateEarlyPurchase(uint256 earlyPurchaseIndex)
external
noEther
onlyOwner
onlyEarlyPurchasesLoaded
onlyBeforeCrowdsale
returns (bool)
{
assert(numberOfRawEarlyPurchases() > earlyPurchaseIndex); // Array Index Out of Bounds Exception
for (uint256 i; i < invalidEarlyPurchaseIndexes.length; i++) {
assert(invalidEarlyPurchaseIndexes[i] != earlyPurchaseIndex);
}
invalidEarlyPurchaseIndexes.push(earlyPurchaseIndex);
EarlyPurchaseInvalidated(earlyPurchaseIndex);
return true;
}
/**
* @dev Checks whether early purchase is invalid
* @param earlyPurchaseIndex Index number of the purchase
*/
function isInvalidEarlyPurchase(uint256 earlyPurchaseIndex)
constant
noEther
public
returns (bool)
{
assert(numberOfRawEarlyPurchases() > earlyPurchaseIndex); // Array Index Out of Bounds Exception
for (uint256 i; i < invalidEarlyPurchaseIndexes.length; i++) {
if (invalidEarlyPurchaseIndexes[i] == earlyPurchaseIndex) {
return true;
}
}
return false;
}
/**
* @dev Amends a given early purchase with data
* @param earlyPurchaseIndex Index number of the purchase
* @param purchaser Purchaser's address
* @param amount Value of purchase
* @param purchasedAt Purchase timestamp
*/
function amendEarlyPurchase(uint256 earlyPurchaseIndex, address purchaser, uint256 amount, uint256 purchasedAt)
external
noEther
onlyOwner
onlyEarlyPurchasesLoaded
onlyBeforeCrowdsale
returns (bool)
{
assert(purchasedAt != 0 || purchasedAt <= now);
assert(numberOfRawEarlyPurchases() > earlyPurchaseIndex);
assert(!isInvalidEarlyPurchase(earlyPurchaseIndex)); // Invalid early purchase cannot be amended
if (!isAmendedEarlyPurchase(earlyPurchaseIndex)) {
amendedEarlyPurchaseIndexes.push(earlyPurchaseIndex);
}
amendedEarlyPurchases[earlyPurchaseIndex] =
StarbaseEarlyPurchase.EarlyPurchase(purchaser, amount, purchasedAt);
EarlyPurchaseAmended(earlyPurchaseIndex);
return true;
}
/**
* @dev Checks whether early purchase is amended
* @param earlyPurchaseIndex Index number of the purchase
*/
function isAmendedEarlyPurchase(uint256 earlyPurchaseIndex)
constant
noEther
returns (bool)
{
assert(numberOfRawEarlyPurchases() > earlyPurchaseIndex); // Array Index Out of Bounds Exception
for (uint256 i; i < amendedEarlyPurchaseIndexes.length; i++) {
if (amendedEarlyPurchaseIndexes[i] == earlyPurchaseIndex) {
return true;
}
}
return false;
}
/**
* @dev Loads early purchases data to StarbaseEarlyPurchaseAmendment contract
* @param starbaseEarlyPurchaseAddress Address from starbase early purchase
*/
function loadStarbaseEarlyPurchases(address starbaseEarlyPurchaseAddress)
external
noEther
onlyOwner
onlyBeforeCrowdsale
returns (bool)
{
assert(starbaseEarlyPurchaseAddress != 0 ||
address(starbaseEarlyPurchase) == 0);
starbaseEarlyPurchase = StarbaseEarlyPurchase(starbaseEarlyPurchaseAddress);
assert(starbaseEarlyPurchase.earlyPurchaseClosedAt() != 0); // the early purchase must be closed
return true;
}
/**
* @dev Contract constructor function. It sets owner
*/
function StarbaseEarlyPurchaseAmendment() noEther {
owner = msg.sender;
}
/**
* Internal functions
*/
/**
* @dev Normalizes early purchases data
*/
function normalizedEarlyPurchases()
constant
internal
returns (StarbaseEarlyPurchase.EarlyPurchase[] normalizedEP)
{
uint256 rawEPCount = numberOfRawEarlyPurchases();
normalizedEP = new StarbaseEarlyPurchase.EarlyPurchase[](
rawEPCount - invalidEarlyPurchaseIndexes.length);
uint256 normalizedIdx;
for (uint256 i; i < rawEPCount; i++) {
if (isInvalidEarlyPurchase(i)) {
continue; // invalid early purchase should be ignored
}
StarbaseEarlyPurchase.EarlyPurchase memory ep;
if (isAmendedEarlyPurchase(i)) {
ep = amendedEarlyPurchases[i]; // amended early purchase should take a priority
} else {
ep = getEarlyPurchase(i);
}
normalizedEP[normalizedIdx] = ep;
normalizedIdx++;
}
}
/**
* @dev Fetches early purchases data
*/
function getEarlyPurchase(uint256 earlyPurchaseIndex)
internal
constant
onlyEarlyPurchasesLoaded
returns (StarbaseEarlyPurchase.EarlyPurchase)
{
var (purchaser, amount, purchasedAt) =
starbaseEarlyPurchase.earlyPurchases(earlyPurchaseIndex);
return StarbaseEarlyPurchase.EarlyPurchase(purchaser, amount, purchasedAt);
}
/**
* @dev Returns raw number of early purchases
*/
function numberOfRawEarlyPurchases()
internal
constant
onlyEarlyPurchasesLoaded
returns (uint256)
{
return starbaseEarlyPurchase.numberOfEarlyPurchases();
}
}
/**
* @title Crowdsale contract - Starbase crowdsale to create STAR.
* @author Starbase PTE. LTD. - <[email protected]>
*/
contract StarbaseCrowdsale is Ownable {
/*
* Events
*/
event CrowdsaleEnded(uint256 endedAt);
event StarBasePurchasedWithEth(address purchaser, uint256 amount, uint256 rawAmount, uint256 cnyEthRate, uint256 bonusTokensPercentage);
event StarBasePurchasedOffChain(address purchaser, uint256 amount, uint256 rawAmount, uint256 cnyBtcRate, uint256 bonusTokensPercentage, string data);
event CnyEthRateUpdated(uint256 cnyEthRate);
event CnyBtcRateUpdated(uint256 cnyBtcRate);
event QualifiedPartnerAddress(address qualifiedPartner);
event PurchaseInvalidated(uint256 purchaseIdx);
event PurchaseAmended(uint256 purchaseIdx);
/**
* External contracts
*/
AbstractStarbaseToken public starbaseToken;
StarbaseEarlyPurchaseAmendment public starbaseEpAmendment;
/**
* Constants
*/
uint256 constant public crowdsaleTokenAmount = 125000000e18;
uint256 constant public earlyPurchaseTokenAmount = 50000000e18;
uint256 constant public MIN_INVESTMENT = 1; // min is 1 Wei
uint256 constant public MAX_CROWDSALE_CAP = 60000000; // approximately 9M USD for the crowdsale(CS). 1M (by EP) + 9M (by CS) = 10M (Total)
string public constant PURCHASE_AMOUNT_UNIT = 'CNY'; // Chinese Yuan
/**
* Types
*/
struct CrowdsalePurchase {
address purchaser;
uint256 amount; // CNY based amount with bonus
uint256 rawAmount; // CNY based amount no bonus
uint256 purchasedAt; // timestamp
string data; // additional data (e.g. Tx ID of Bitcoin)
uint256 bonus;
}
struct QualifiedPartners {
uint256 amountCap;
uint256 amountRaised;
bool bonaFide;
uint256 commissionFeePercentage; // example 5 will calculate the percentage as 5%
}
/**
* Storage
*/
address public workshop; // holds undelivered STARs
uint public numOfDeliveredCrowdsalePurchases = 0; // index to keep the number of crowdsale purchases have already been processed by `deliverPurchasedTokens`
uint public numOfDeliveredEarlyPurchases = 0; // index to keep the number of early purchases have already been processed by `deliverPurchasedTokens`
uint256 public numOfLoadedEarlyPurchases = 0; // index to keep the number of early purchases that have already been loaded by `loadEarlyPurchases`
address[] public earlyPurchasers;
mapping (address => QualifiedPartners) public qualifiedPartners;
mapping (address => uint256) public earlyPurchasedAmountBy; // early purchased amount in CNY per purchasers' address
bool public earlyPurchasesLoaded = false; // returns whether all early purchases are loaded into this contract
// crowdsale
uint256 public purchaseStartBlock; // crowdsale purchases can be accepted from this block number
uint256 public startDate;
uint256 public endedAt;
CrowdsalePurchase[] public crowdsalePurchases;
uint256 public cnyBtcRate; // this rate won't be used from a smart contract function but external system
uint256 public cnyEthRate;
// bonus milestones
uint256 public firstBonusSalesEnds;
uint256 public secondBonusSalesEnds;
uint256 public thirdBonusSalesEnds;
uint256 public fourthBonusSalesEnds;
uint256 public fifthBonusSalesEnds;
uint256 public firstExtendedBonusSalesEnds;
uint256 public secondExtendedBonusSalesEnds;
uint256 public thirdExtendedBonusSalesEnds;
uint256 public fourthExtendedBonusSalesEnds;
uint256 public fifthExtendedBonusSalesEnds;
uint256 public sixthExtendedBonusSalesEnds;
// after the crowdsale
mapping(uint256 => CrowdsalePurchase) public invalidatedOrigPurchases; // Original purchase which was invalidated by owner
mapping(uint256 => CrowdsalePurchase) public amendedOrigPurchases; // Original purchase which was amended by owner
mapping (address => uint256) public numOfPurchasedTokensOnCsBy; // the number of tokens purchased on the crowdsale by a purchaser
mapping (address => uint256) public numOfPurchasedTokensOnEpBy; // the number of tokens early purchased by a purchaser
/**
* Modifiers
*/
modifier minInvestment() {
// User has to send at least the ether value of one token.
assert(msg.value >= MIN_INVESTMENT);
_;
}
modifier whenEnded() {
assert(isEnded());
_;
}
modifier hasBalance() {
assert(this.balance > 0);
_;
}
modifier rateIsSet(uint256 _rate) {
assert(_rate != 0);
_;
}
modifier whenNotEnded() {
assert(!isEnded());
_;
}
modifier tokensNotDelivered() {
assert(numOfDeliveredCrowdsalePurchases == 0);
assert(numOfDeliveredEarlyPurchases == 0);
_;
}
modifier onlyFundraiser() {
assert(address(starbaseToken) != 0);
assert(starbaseToken.isFundraiser(msg.sender));
_;
}
/**
* Contract functions
*/
/**
* @dev Contract constructor function sets owner and start date.
* @param workshopAddr The address that will hold undelivered Star tokens
* @param starbaseEpAddr The address that holds the early purchasers Star tokens
*/
function StarbaseCrowdsale(address workshopAddr, address starbaseEpAddr) {
require(workshopAddr != 0 && starbaseEpAddr != 0);
owner = msg.sender;
workshop = workshopAddr;
starbaseEpAmendment = StarbaseEarlyPurchaseAmendment(starbaseEpAddr);
}
/**
* @dev Fallback accepts payment for Star tokens with Eth
*/
function() payable {
redirectToPurchase();
}
/**
* External functions
*/
/**
* @dev Setup function sets external contracts' addresses.
* @param starbaseTokenAddress Token address.
* @param _purchaseStartBlock Block number to start crowdsale
*/
function setup(address starbaseTokenAddress, uint256 _purchaseStartBlock)
external
onlyOwner
returns (bool)
{
assert(address(starbaseToken) == 0);
starbaseToken = AbstractStarbaseToken(starbaseTokenAddress);
purchaseStartBlock = _purchaseStartBlock;
return true;
}
/**
* @dev Allows owner to record a purchase made outside of Ethereum blockchain
* @param purchaser Address of a purchaser
* @param rawAmount Purchased amount in CNY
* @param purchasedAt Timestamp at the purchase made
* @param data Identifier as an evidence of the purchase (e.g. btc:1xyzxyz)
*/
function recordOffchainPurchase(
address purchaser,
uint256 rawAmount,
uint256 purchasedAt,
string data
)
external
onlyFundraiser
whenNotEnded
rateIsSet(cnyBtcRate)
returns (bool)
{
require(purchaseStartBlock > 0 && block.number >= purchaseStartBlock);
if (startDate == 0) {
startCrowdsale(block.timestamp);
}
uint256 bonusTier = getBonusTier();
uint amount = recordPurchase(purchaser, rawAmount, purchasedAt, data, bonusTier);
StarBasePurchasedOffChain(purchaser, amount, rawAmount, cnyBtcRate, bonusTier, data);
return true;
}
/**
* @dev Transfers raised funds to company's wallet address at any given time.
*/
function withdrawForCompany()
external
onlyFundraiser
hasBalance
{
address company = starbaseToken.company();
require(company != address(0));
company.transfer(this.balance);
}
/**
* @dev Update the CNY/ETH rate to record purchases in CNY
*/
function updateCnyEthRate(uint256 rate)
external
onlyFundraiser
returns (bool)
{
cnyEthRate = rate;
CnyEthRateUpdated(cnyEthRate);
return true;
}
/**
* @dev Update the CNY/BTC rate to record purchases in CNY
*/
function updateCnyBtcRate(uint256 rate)
external
onlyFundraiser
returns (bool)
{
cnyBtcRate = rate;
CnyBtcRateUpdated(cnyBtcRate);
return true;
}
/**
* @dev Allow for the possibilyt for contract owner to start crowdsale
*/
function ownerStartsCrowdsale(uint256 timestamp)
external
onlyOwner
{
assert(startDate == 0 && block.number >= purchaseStartBlock); // overwriting startDate is not permitted and it should be after the crowdsale start block
startCrowdsale(timestamp);
}
/**
* @dev Ends crowdsale
* @param timestamp Timestamp at the crowdsale ended
*/
function endCrowdsale(uint256 timestamp)
external
onlyOwner
{
assert(timestamp > 0 && timestamp <= now);
assert(endedAt == 0); // overwriting time is not permitted
endedAt = timestamp;
CrowdsaleEnded(endedAt);
}
/**
* @dev Invalidate a crowdsale purchase if something is wrong with it
* @param purchaseIdx Index number of the crowdsalePurchases to invalidate
*/
function invalidatePurchase(uint256 purchaseIdx)
external
onlyOwner
whenEnded
tokensNotDelivered
returns (bool)
{
CrowdsalePurchase memory purchase = crowdsalePurchases[purchaseIdx];
assert(purchase.purchaser != 0 && purchase.amount != 0);
crowdsalePurchases[purchaseIdx].amount = 0;
crowdsalePurchases[purchaseIdx].rawAmount = 0;
invalidatedOrigPurchases[purchaseIdx] = purchase;
PurchaseInvalidated(purchaseIdx);
return true;
}
/**
* @dev Amend a crowdsale purchase if something is wrong with it
* @param purchaseIdx Index number of the crowdsalePurchases to invalidate
* @param purchaser Address of the buyer
* @param amount Purchased tokens as per the CNY rate used
* @param rawAmount Purchased tokens as per the CNY rate used without the bonus
* @param purchasedAt Timestamp at the purchase made
* @param data Identifier as an evidence of the purchase (e.g. btc:1xyzxyz)
* @param bonus bonus milestones of the purchase
*/
function amendPurchase(
uint256 purchaseIdx,
address purchaser,
uint256 amount,
uint256 rawAmount,
uint256 purchasedAt,
string data,
uint256 bonus
)
external
onlyOwner
whenEnded
tokensNotDelivered
returns (bool)
{
CrowdsalePurchase memory purchase = crowdsalePurchases[purchaseIdx];
assert(purchase.purchaser != 0 && purchase.amount != 0);
amendedOrigPurchases[purchaseIdx] = purchase;
crowdsalePurchases[purchaseIdx] =
CrowdsalePurchase(purchaser, amount, rawAmount, purchasedAt, data, bonus);
PurchaseAmended(purchaseIdx);
return true;
}
/**
* @dev Deliver tokens to purchasers according to their purchase amount in CNY
*/
function deliverPurchasedTokens()
external
onlyOwner
whenEnded
returns (bool)
{
assert(earlyPurchasesLoaded);
assert(address(starbaseToken) != 0);
uint256 totalAmountOfPurchasesInCny = totalRaisedAmountInCny(); // totalPreSale + totalCrowdsale
for (uint256 i = numOfDeliveredCrowdsalePurchases; i < crowdsalePurchases.length && msg.gas > 200000; i++) {
CrowdsalePurchase memory purchase = crowdsalePurchases[i];
if (purchase.amount == 0) {
continue; // skip invalidated purchase
}
/*
* โValueโ refers to the contribution of the User:
* {crowdsale_purchaser_token_amount} =
* {crowdsale_token_amount} * {crowdsalePurchase_value} / {earlypurchase_value} + {crowdsale_value}.
*
* Example: If a User contributes during the Contribution Period 100 CNY (including applicable
* Bonus, if any) and the total amount early purchases amounts to 6โ000โ000 CNY
* and total amount raised during the Contribution Period is 30โ000โ000, then he will get
* 347.22 STAR = 125โ000โ000 STAR * 100 CNY / 30โ000โ000 CNY + 6โ000โ000 CNY.
*/
uint256 crowdsalePurchaseValue = purchase.amount;
uint256 tokenCount = SafeMath.mul(crowdsaleTokenAmount, crowdsalePurchaseValue) / totalAmountOfPurchasesInCny;
numOfPurchasedTokensOnCsBy[purchase.purchaser] = SafeMath.add(numOfPurchasedTokensOnCsBy[purchase.purchaser], tokenCount);
starbaseToken.allocateToCrowdsalePurchaser(purchase.purchaser, tokenCount);
numOfDeliveredCrowdsalePurchases = SafeMath.add(i, 1);
}
for (uint256 j = numOfDeliveredEarlyPurchases; j < earlyPurchasers.length && msg.gas > 200000; j++) {
address earlyPurchaser = earlyPurchasers[j];
/*
* โValueโ refers to the contribution of the User:
* {earlypurchaser_token_amount} =
* {earlypurchaser_token_amount} * ({earlypurchase_value} / {total_earlypurchase_value})
* + {crowdsale_token_amount} * ({earlypurchase_value} / {earlypurchase_value} + {crowdsale_value}).
*
* Example: If an Early Purchaser contributes 100 CNY (including Bonus of 20%) and the
* total amount of early purchases amounts to 6โ000โ000 CNY and the total amount raised
* during the Contribution Period is 30โ000โ000 CNY, then he will get 1180.55 STAR =
* 50โ000โ000 STAR * 100 CNY / 6โ000โ000 CNY + 125โ000โ000 STAR * 100 CNY /
* 30โ000โ000 CNY + 6โ000โ000 CNY
*/
uint256 earlyPurchaserPurchaseValue = earlyPurchasedAmountBy[earlyPurchaser];
uint256 epTokenCalculationFromEPTokenAmount = SafeMath.mul(earlyPurchaseTokenAmount, earlyPurchaserPurchaseValue) / totalAmountOfEarlyPurchases();
uint256 epTokenCalculationFromCrowdsaleTokenAmount = SafeMath.mul(crowdsaleTokenAmount, earlyPurchaserPurchaseValue) / totalAmountOfPurchasesInCny;
uint256 epTokenCount = SafeMath.add(epTokenCalculationFromEPTokenAmount, epTokenCalculationFromCrowdsaleTokenAmount);
numOfPurchasedTokensOnEpBy[earlyPurchaser] = SafeMath.add(numOfPurchasedTokensOnEpBy[earlyPurchaser], epTokenCount);
starbaseToken.allocateToCrowdsalePurchaser(earlyPurchaser, epTokenCount);
numOfDeliveredEarlyPurchases = SafeMath.add(j, 1);
}
return true;
}
/**
* @dev Load early purchases from the contract keeps track of them
*/
function loadEarlyPurchases() external onlyOwner returns (bool) {
if (earlyPurchasesLoaded) {
return false; // all EPs have already been loaded
}
uint256 numOfOrigEp = starbaseEpAmendment
.starbaseEarlyPurchase()
.numberOfEarlyPurchases();
for (uint256 i = numOfLoadedEarlyPurchases; i < numOfOrigEp && msg.gas > 200000; i++) {
if (starbaseEpAmendment.isInvalidEarlyPurchase(i)) {
continue;
}
var (purchaser, amount,) =
starbaseEpAmendment.isAmendedEarlyPurchase(i)
? starbaseEpAmendment.amendedEarlyPurchases(i)
: starbaseEpAmendment.earlyPurchases(i);
if (amount > 0) {
if (earlyPurchasedAmountBy[purchaser] == 0) {
earlyPurchasers.push(purchaser);
}
// each early purchaser receives 20% bonus
uint256 bonus = SafeMath.mul(amount, 20) / 100;
uint256 amountWithBonus = SafeMath.add(amount, bonus);
earlyPurchasedAmountBy[purchaser] += amountWithBonus;
}
}
numOfLoadedEarlyPurchases += i;
assert(numOfLoadedEarlyPurchases <= numOfOrigEp);
if (numOfLoadedEarlyPurchases == numOfOrigEp) {
earlyPurchasesLoaded = true; // enable the flag
}
return true;
}
/**
* @dev Set qualified crowdsale partner i.e. Bitcoin Suisse address
* @param _qualifiedPartner Address of the qualified partner that can purchase during crowdsale
* @param _amountCap Ether value which partner is able to contribute
* @param _commissionFeePercentage Integer that represents the fee to pay qualified partner 5 is 5%
*/
function setQualifiedPartner(address _qualifiedPartner, uint256 _amountCap, uint256 _commissionFeePercentage)
external
onlyOwner
{
assert(!qualifiedPartners[_qualifiedPartner].bonaFide);
qualifiedPartners[_qualifiedPartner].bonaFide = true;
qualifiedPartners[_qualifiedPartner].amountCap = _amountCap;
qualifiedPartners[_qualifiedPartner].commissionFeePercentage = _commissionFeePercentage;
QualifiedPartnerAddress(_qualifiedPartner);
}
/**
* @dev Remove address from qualified partners list.
* @param _qualifiedPartner Address to be removed from the list.
*/
function unlistQualifiedPartner(address _qualifiedPartner) external onlyOwner {
assert(qualifiedPartners[_qualifiedPartner].bonaFide);
qualifiedPartners[_qualifiedPartner].bonaFide = false;
}
/**
* @dev Update whitelisted address amount allowed to raise during the presale.
* @param _qualifiedPartner Qualified Partner address to be updated.
* @param _amountCap Amount that the address is able to raise during the presale.
*/
function updateQualifiedPartnerCapAmount(address _qualifiedPartner, uint256 _amountCap) external onlyOwner {
assert(qualifiedPartners[_qualifiedPartner].bonaFide);
qualifiedPartners[_qualifiedPartner].amountCap = _amountCap;
}
/**
* Public functions
*/
/**
* @dev Returns boolean for whether crowdsale has ended
*/
function isEnded() constant public returns (bool) {
return (endedAt > 0 && endedAt <= now);
}
/**
* @dev Returns number of purchases to date.
*/
function numOfPurchases() constant public returns (uint256) {
return crowdsalePurchases.length;
}
/**
* @dev Calculates total amount of tokens purchased includes bonus tokens.
*/
function totalAmountOfCrowdsalePurchases() constant public returns (uint256 amount) {
for (uint256 i; i < crowdsalePurchases.length; i++) {
amount = SafeMath.add(amount, crowdsalePurchases[i].amount);
}
}
/**
* @dev Calculates total amount of tokens purchased without bonus conversion.
*/
function totalAmountOfCrowdsalePurchasesWithoutBonus() constant public returns (uint256 amount) {
for (uint256 i; i < crowdsalePurchases.length; i++) {
amount = SafeMath.add(amount, crowdsalePurchases[i].rawAmount);
}
}
/**
* @dev Returns total raised amount in CNY (includes EP) and bonuses
*/
function totalRaisedAmountInCny() constant public returns (uint256) {
return SafeMath.add(totalAmountOfEarlyPurchases(), totalAmountOfCrowdsalePurchases());
}
/**
* @dev Returns total amount of early purchases in CNY
*/
function totalAmountOfEarlyPurchases() constant public returns(uint256) {
return starbaseEpAmendment.totalAmountOfEarlyPurchases();
}
/**
* @dev Allows qualified crowdsale partner to purchase Star Tokens
*/
function purchaseAsQualifiedPartner()
payable
public
rateIsSet(cnyEthRate)
returns (bool)
{
require(qualifiedPartners[msg.sender].bonaFide);
qualifiedPartners[msg.sender].amountRaised = SafeMath.add(msg.value, qualifiedPartners[msg.sender].amountRaised);
assert(qualifiedPartners[msg.sender].amountRaised <= qualifiedPartners[msg.sender].amountCap);
uint256 bonusTier = 30; // Pre sale purchasers get 30 percent bonus
uint256 rawAmount = SafeMath.mul(msg.value, cnyEthRate) / 1e18;
uint amount = recordPurchase(msg.sender, rawAmount, now, '', bonusTier);
if (qualifiedPartners[msg.sender].commissionFeePercentage > 0) {
sendQualifiedPartnerCommissionFee(msg.sender, msg.value);
}
StarBasePurchasedWithEth(msg.sender, amount, rawAmount, cnyEthRate, bonusTier);
return true;
}
/**
* @dev Allows user to purchase STAR tokens with Ether
*/
function purchaseWithEth()
payable
public
minInvestment
whenNotEnded
rateIsSet(cnyEthRate)
returns (bool)
{
require(purchaseStartBlock > 0 && block.number >= purchaseStartBlock);
if (startDate == 0) {
startCrowdsale(block.timestamp);
}
uint256 bonusTier = getBonusTier();
uint256 rawAmount = SafeMath.mul(msg.value, cnyEthRate) / 1e18;
uint amount = recordPurchase(msg.sender, rawAmount, now, '', bonusTier);
StarBasePurchasedWithEth(msg.sender, amount, rawAmount, cnyEthRate, bonusTier);
return true;
}
/**
* Internal functions
*/
/**
* @dev Initializes Starbase crowdsale
*/
function startCrowdsale(uint256 timestamp) internal {
startDate = timestamp;
// set token bonus milestones
firstBonusSalesEnds = startDate + 7 days; // 1. 1st ~ 7th day
secondBonusSalesEnds = firstBonusSalesEnds + 14 days; // 2. 8th ~ 21st day
thirdBonusSalesEnds = secondBonusSalesEnds + 14 days; // 3. 22nd ~ 35th day
fourthBonusSalesEnds = thirdBonusSalesEnds + 7 days; // 4. 36th ~ 42nd day
fifthBonusSalesEnds = fourthBonusSalesEnds + 3 days; // 5. 43rd ~ 45th day
// extended sales bonus milestones
firstExtendedBonusSalesEnds = fifthBonusSalesEnds + 3 days; // 1. 46th ~ 48th day
secondExtendedBonusSalesEnds = firstExtendedBonusSalesEnds + 3 days; // 2. 49th ~ 51st day
thirdExtendedBonusSalesEnds = secondExtendedBonusSalesEnds + 3 days; // 3. 52nd ~ 54th day
fourthExtendedBonusSalesEnds = thirdExtendedBonusSalesEnds + 3 days; // 4. 55th ~ 57th day
fifthExtendedBonusSalesEnds = fourthExtendedBonusSalesEnds + 3 days; // 5. 58th ~ 60th day
sixthExtendedBonusSalesEnds = fifthExtendedBonusSalesEnds + 60 days; // 6. 61st ~ 120th day
}
/**
* @dev Abstract record of a purchase to Tokens
* @param purchaser Address of the buyer
* @param rawAmount Amount in CNY as per the CNY/ETH rate used
* @param timestamp Timestamp at the purchase made
* @param data Identifier as an evidence of the purchase (e.g. btc:1xyzxyz)
* @param bonusTier bonus milestones of the purchase
*/
function recordPurchase(
address purchaser,
uint256 rawAmount,
uint256 timestamp,
string data,
uint256 bonusTier
)
internal
returns(uint256 amount)
{
amount = rawAmount; // amount to check reach of max cap. it does not care for bonus tokens here
// presale transfers which occurs before the crowdsale ignores the crowdsale hard cap
if (block.number >= purchaseStartBlock) {
assert(totalAmountOfCrowdsalePurchasesWithoutBonus() <= MAX_CROWDSALE_CAP);
uint256 crowdsaleTotalAmountAfterPurchase = SafeMath.add(totalAmountOfCrowdsalePurchasesWithoutBonus(), amount);
// check whether purchase goes over the cap and send the difference back to the purchaser.
if (crowdsaleTotalAmountAfterPurchase > MAX_CROWDSALE_CAP) {
uint256 difference = SafeMath.sub(crowdsaleTotalAmountAfterPurchase, MAX_CROWDSALE_CAP);
uint256 ethValueToReturn = SafeMath.mul(difference, 1e18) / cnyEthRate;
purchaser.transfer(ethValueToReturn);
amount = SafeMath.sub(amount, difference);
rawAmount = amount;
}
}
uint256 covertedAmountwWithBonus = SafeMath.mul(amount, bonusTier) / 100;
amount = SafeMath.add(amount, covertedAmountwWithBonus); // at this point amount bonus is calculated
CrowdsalePurchase memory purchase = CrowdsalePurchase(purchaser, amount, rawAmount, timestamp, data, bonusTier);
crowdsalePurchases.push(purchase);
return amount;
}
/**
* @dev Fetchs Bonus tier percentage per bonus milestones
*/
function getBonusTier() internal returns (uint256) {
bool firstBonusSalesPeriod = now >= startDate && now <= firstBonusSalesEnds; // 1st ~ 7th day get 20% bonus
bool secondBonusSalesPeriod = now > firstBonusSalesEnds && now <= secondBonusSalesEnds; // 8th ~ 21st day get 15% bonus
bool thirdBonusSalesPeriod = now > secondBonusSalesEnds && now <= thirdBonusSalesEnds; // 22nd ~ 35th day get 10% bonus
bool fourthBonusSalesPeriod = now > thirdBonusSalesEnds && now <= fourthBonusSalesEnds; // 36th ~ 42nd day get 5% bonus
bool fifthBonusSalesPeriod = now > fourthBonusSalesEnds && now <= fifthBonusSalesEnds; // 43rd and 45th day get 0% bonus
// extended bonus sales
bool firstExtendedBonusSalesPeriod = now > fifthBonusSalesEnds && now <= firstExtendedBonusSalesEnds; // extended sales 46th ~ 48th day get 20% bonus
bool secondExtendedBonusSalesPeriod = now > firstExtendedBonusSalesEnds && now <= secondExtendedBonusSalesEnds; // 49th ~ 51st 15% bonus
bool thirdExtendedBonusSalesPeriod = now > secondExtendedBonusSalesEnds && now <= thirdExtendedBonusSalesEnds; // 52nd ~ 54th day get 10% bonus
bool fourthExtendedBonusSalesPeriod = now > thirdExtendedBonusSalesEnds && now <= fourthExtendedBonusSalesEnds; // 55th ~ 57th day day get 5% bonus
bool fifthExtendedBonusSalesPeriod = now > fourthExtendedBonusSalesEnds && now <= fifthExtendedBonusSalesEnds; // 58th ~ 60th day get 0% bonus
bool sixthExtendedBonusSalesPeriod = now > fifthExtendedBonusSalesEnds && now <= sixthExtendedBonusSalesEnds; // 61st ~ 120th day get {number_of_days} - 60 * 1% bonus
if (firstBonusSalesPeriod || firstExtendedBonusSalesPeriod) return 20;
if (secondBonusSalesPeriod || secondExtendedBonusSalesPeriod) return 15;
if (thirdBonusSalesPeriod || thirdExtendedBonusSalesPeriod) return 10;
if (fourthBonusSalesPeriod || fourthExtendedBonusSalesPeriod) return 5;
if (fifthBonusSalesPeriod || fifthExtendedBonusSalesPeriod) return 0;
if (sixthExtendedBonusSalesPeriod) {
uint256 DAY_IN_SECONDS = 86400;
uint256 secondsSinceStartDate = SafeMath.sub(now, startDate);
uint256 numberOfDays = secondsSinceStartDate / DAY_IN_SECONDS;
return SafeMath.sub(numberOfDays, 60);
}
}
/**
* @dev Fetchs Bonus tier percentage per bonus milestones
* @dev qualifiedPartner Address of partners that participated in pre sale
* @dev amountSent Value sent by qualified partner
*/
function sendQualifiedPartnerCommissionFee(address qualifiedPartner, uint256 amountSent) internal {
//calculate the commission fee to send to qualified partner
uint256 commissionFeePercentageCalculationAmount = SafeMath.mul(amountSent, qualifiedPartners[qualifiedPartner].commissionFeePercentage) / 100;
// send commission fee amount
qualifiedPartner.transfer(commissionFeePercentageCalculationAmount);
}
/**
* @dev redirectToPurchase Redirect to adequate purchase function within the smart contract
*/
function redirectToPurchase() internal {
if (block.number < purchaseStartBlock) {
purchaseAsQualifiedPartner();
} else {
purchaseWithEth();
}
}
} | * @dev Fetches early purchases data/ | function getEarlyPurchase(uint256 earlyPurchaseIndex)
internal
constant
onlyEarlyPurchasesLoaded
returns (StarbaseEarlyPurchase.EarlyPurchase)
{
var (purchaser, amount, purchasedAt) =
starbaseEarlyPurchase.earlyPurchases(earlyPurchaseIndex);
return StarbaseEarlyPurchase.EarlyPurchase(purchaser, amount, purchasedAt);
}
| 12,901,631 | [
1,
14288,
11646,
5405,
343,
3304,
501,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
4774,
20279,
23164,
12,
11890,
5034,
11646,
23164,
1016,
13,
203,
3639,
2713,
203,
3639,
5381,
203,
3639,
1338,
41,
20279,
10262,
343,
3304,
8835,
203,
3639,
1135,
261,
18379,
1969,
41,
20279,
23164,
18,
41,
20279,
23164,
13,
203,
565,
288,
203,
3639,
569,
261,
12688,
343,
14558,
16,
3844,
16,
5405,
343,
8905,
861,
13,
273,
203,
5411,
10443,
1969,
41,
20279,
23164,
18,
2091,
715,
10262,
343,
3304,
12,
2091,
715,
23164,
1016,
1769,
203,
3639,
327,
934,
297,
1969,
41,
20279,
23164,
18,
41,
20279,
23164,
12,
12688,
343,
14558,
16,
3844,
16,
5405,
343,
8905,
861,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
/**
*Submitted for verification at Etherscan.io on 2021-09-11
*/
// SPDX-License-Identifier: MIT
// File: FunkyOstriches.sol
pragma solidity ^0.8.7;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
/*
* @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) {
return msg.data;
}
}
/**
* @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.
*/
abstract 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() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
/**
* @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) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @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");
(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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) private pure returns (bytes memory) {
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
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` 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 tokenId
) internal virtual {}
}
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _allTokens.length;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
super._beforeTokenTransfer(from, to, tokenId);
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = ERC721.balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
// rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
}
pragma solidity ^0.8.4;
contract FunkyOstriches is ERC721Enumerable, Ownable {
using Address for address;
// Sale state
bool public saleIsActive = false;
// Reserved for the team, customs, giveaways, collabs and so on.
uint256 public reserved = 100;
// Price of each token
uint256 public price = 0.04 ether;
// Maximum limit of tokens that can ever exist
uint256 constant MAX_SUPPLY = 7500;
// The base link that leads to the image / video of the token
string public baseTokenURI;
// Withdraw address
address withdrawAddress = 0x6b95C8AC63B16376cf137c28d065932f2236CbC0;
constructor (string memory newBaseURI) ERC721 ("Funky Ostriches", "OSTRICH") {
setBaseURI(newBaseURI);
}
// Override so the openzeppelin tokenURI() method will use this method to create the full tokenURI instead
function _baseURI() internal view virtual override returns (string memory) {
return baseTokenURI;
}
// See which address owns which tokens
function tokensOfOwner(address addr) public view returns(uint256[] memory) {
uint256 tokenCount = balanceOf(addr);
uint256[] memory tokensId = new uint256[](tokenCount);
for(uint256 i; i < tokenCount; i++){
tokensId[i] = tokenOfOwnerByIndex(addr, i);
}
return tokensId;
}
// Standard mint function
function mint(uint256 _amount) public payable {
uint256 supply = totalSupply();
require( saleIsActive, "Sale isn't active" );
require( _amount > 0 && _amount < 16, "Can only mint between 1 and 15 tokens at once" );
require( (supply + _amount) <= (MAX_SUPPLY - reserved), "Purchase would exceed maximum supply" );
require( msg.value == price * _amount, "Wrong amount of ETH sent" );
for(uint256 i; i < _amount; i++){
_safeMint( msg.sender, supply + i );
}
}
// Admin minting function to reserve tokens for the team, collabs, customs and giveaways
function mintReserved(address _to, uint256 _amount) public onlyOwner {
// Limited to a publicly set amount
require( _amount <= reserved, "Can't reserve more than set amount" );
reserved -= _amount;
uint256 supply = totalSupply();
for(uint256 i; i < _amount; i++){
_safeMint( _to, supply + i );
}
}
/*
* Sale state
*/
function pauseSale() public onlyOwner() {
require(saleIsActive == true, "Sale is already paused");
saleIsActive = false;
}
function startSale() public onlyOwner() {
require(saleIsActive == false, "Sale has already started");
saleIsActive = true;
}
// Set new baseURI
function setBaseURI(string memory baseURI) public onlyOwner {
baseTokenURI = baseURI;
}
// Set a different price in case ETH changes drastically
function setPrice(uint256 newPrice) public onlyOwner {
price = newPrice;
}
/*
* Withdraw
*/
function withdraw() public onlyOwner {
uint balance = address(this).balance;
require(payable(withdrawAddress).send(balance));
}
} | Standard mint function | function mint(uint256 _amount) public payable {
uint256 supply = totalSupply();
require( saleIsActive, "Sale isn't active" );
require( _amount > 0 && _amount < 16, "Can only mint between 1 and 15 tokens at once" );
require( (supply + _amount) <= (MAX_SUPPLY - reserved), "Purchase would exceed maximum supply" );
require( msg.value == price * _amount, "Wrong amount of ETH sent" );
for(uint256 i; i < _amount; i++){
_safeMint( msg.sender, supply + i );
}
}
| 14,980,788 | [
1,
8336,
312,
474,
445,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
312,
474,
12,
11890,
5034,
389,
8949,
13,
1071,
8843,
429,
288,
203,
3639,
2254,
5034,
14467,
273,
2078,
3088,
1283,
5621,
203,
3639,
2583,
12,
272,
5349,
2520,
3896,
16,
5397,
315,
30746,
5177,
1404,
2695,
6,
11272,
203,
3639,
2583,
12,
389,
8949,
405,
374,
597,
389,
8949,
411,
2872,
16,
377,
315,
2568,
1338,
312,
474,
3086,
404,
471,
4711,
2430,
622,
3647,
6,
11272,
203,
3639,
2583,
12,
261,
2859,
1283,
397,
389,
8949,
13,
1648,
261,
6694,
67,
13272,
23893,
300,
8735,
3631,
315,
23164,
4102,
9943,
4207,
14467,
6,
11272,
203,
3639,
2583,
12,
1234,
18,
1132,
422,
6205,
380,
389,
8949,
16,
282,
315,
13634,
3844,
434,
512,
2455,
3271,
6,
11272,
203,
3639,
364,
12,
11890,
5034,
277,
31,
277,
411,
389,
8949,
31,
277,
27245,
95,
203,
5411,
389,
4626,
49,
474,
12,
1234,
18,
15330,
16,
14467,
397,
277,
11272,
203,
3639,
289,
203,
565,
289,
203,
377,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
interface ERC20 {
function totalSupply() external view returns (uint256 supply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value)
external
returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
function decimals() external view returns (uint256 digits);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
} library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
} library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(ERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*/
function safeApprove(ERC20 token, address spender, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(ERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(ERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(ERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
} interface IFlashLoanReceiver {
function executeOperation(address _reserve, uint256 _amount, uint256 _fee, bytes calldata _params) external;
}
abstract contract ILendingPoolAddressesProvider {
function getLendingPool() public view virtual returns (address);
function setLendingPoolImpl(address _pool) public virtual;
function getLendingPoolCore() public virtual view returns (address payable);
function setLendingPoolCoreImpl(address _lendingPoolCore) public virtual;
function getLendingPoolConfigurator() public virtual view returns (address);
function setLendingPoolConfiguratorImpl(address _configurator) public virtual;
function getLendingPoolDataProvider() public virtual view returns (address);
function setLendingPoolDataProviderImpl(address _provider) public virtual;
function getLendingPoolParametersProvider() public virtual view returns (address);
function setLendingPoolParametersProviderImpl(address _parametersProvider) public virtual;
function getTokenDistributor() public virtual view returns (address);
function setTokenDistributor(address _tokenDistributor) public virtual;
function getFeeProvider() public virtual view returns (address);
function setFeeProviderImpl(address _feeProvider) public virtual;
function getLendingPoolLiquidationManager() public virtual view returns (address);
function setLendingPoolLiquidationManager(address _manager) public virtual;
function getLendingPoolManager() public virtual view returns (address);
function setLendingPoolManager(address _lendingPoolManager) public virtual;
function getPriceOracle() public virtual view returns (address);
function setPriceOracle(address _priceOracle) public virtual;
function getLendingRateOracle() public view virtual returns (address);
function setLendingRateOracle(address _lendingRateOracle) public virtual;
}
library EthAddressLib {
function ethAddress() internal pure returns(address) {
return 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
}
}
abstract contract FlashLoanReceiverBase is IFlashLoanReceiver {
using SafeERC20 for ERC20;
using SafeMath for uint256;
ILendingPoolAddressesProvider public addressesProvider;
constructor(ILendingPoolAddressesProvider _provider) public {
addressesProvider = _provider;
}
receive () external virtual payable {}
function transferFundsBackToPoolInternal(address _reserve, uint256 _amount) internal {
address payable core = addressesProvider.getLendingPoolCore();
transferInternal(core,_reserve, _amount);
}
function transferInternal(address payable _destination, address _reserve, uint256 _amount) internal {
if(_reserve == EthAddressLib.ethAddress()) {
//solium-disable-next-line
_destination.call{value: _amount}("");
return;
}
ERC20(_reserve).safeTransfer(_destination, _amount);
}
function getBalanceInternal(address _target, address _reserve) internal view returns(uint256) {
if(_reserve == EthAddressLib.ethAddress()) {
return _target.balance;
}
return ERC20(_reserve).balanceOf(_target);
}
} abstract contract DSProxyInterface {
/// Truffle wont compile if this isn't commented
// function execute(bytes memory _code, bytes memory _data)
// public virtual
// payable
// returns (address, bytes32);
function execute(address _target, bytes memory _data) public virtual payable returns (bytes32);
function setCache(address _cacheAddr) public virtual payable returns (bool);
function owner() public virtual returns (address);
} contract DSMath {
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x);
}
function div(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x / y;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x <= y ? x : y;
}
function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x >= y ? x : y;
}
function imin(int256 x, int256 y) internal pure returns (int256 z) {
return x <= y ? x : y;
}
function imax(int256 x, int256 y) internal pure returns (int256 z) {
return x >= y ? x : y;
}
uint256 constant WAD = 10**18;
uint256 constant RAY = 10**27;
function wmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint256 x, uint256 n) internal pure returns (uint256 z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
} abstract contract TokenInterface {
function allowance(address, address) public virtual returns (uint256);
function balanceOf(address) public virtual returns (uint256);
function approve(address, uint256) public virtual;
function transfer(address, uint256) public virtual returns (bool);
function transferFrom(address, address, uint256) public virtual returns (bool);
function deposit() public virtual payable;
function withdraw(uint256) public virtual;
} interface ExchangeInterfaceV2 {
function sell(address _srcAddr, address _destAddr, uint _srcAmount) external payable returns (uint);
function buy(address _srcAddr, address _destAddr, uint _destAmount) external payable returns(uint);
function getSellRate(address _srcAddr, address _destAddr, uint _srcAmount) external view returns (uint);
function getBuyRate(address _srcAddr, address _destAddr, uint _srcAmount) external view returns (uint);
} contract AdminAuth {
using SafeERC20 for ERC20;
address public owner;
address public admin;
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
constructor() public {
owner = msg.sender;
}
/// @notice Admin is set by owner first time, after that admin is super role and has permission to change owner
/// @param _admin Address of multisig that becomes admin
function setAdminByOwner(address _admin) public {
require(msg.sender == owner);
require(admin == address(0));
admin = _admin;
}
/// @notice Admin is able to set new admin
/// @param _admin Address of multisig that becomes new admin
function setAdminByAdmin(address _admin) public {
require(msg.sender == admin);
admin = _admin;
}
/// @notice Admin is able to change owner
/// @param _owner Address of new owner
function setOwnerByAdmin(address _owner) public {
require(msg.sender == admin);
owner = _owner;
}
/// @notice Destroy the contract
function kill() public onlyOwner {
selfdestruct(payable(owner));
}
/// @notice withdraw stuck funds
function withdrawStuckFunds(address _token, uint _amount) public onlyOwner {
if (_token == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
payable(owner).transfer(_amount);
} else {
ERC20(_token).safeTransfer(owner, _amount);
}
}
} contract ZrxAllowlist is AdminAuth {
mapping (address => bool) public zrxAllowlist;
mapping(address => bool) private nonPayableAddrs;
constructor() public {
zrxAllowlist[0x6958F5e95332D93D21af0D7B9Ca85B8212fEE0A5] = true;
zrxAllowlist[0x61935CbDd02287B511119DDb11Aeb42F1593b7Ef] = true;
zrxAllowlist[0xDef1C0ded9bec7F1a1670819833240f027b25EfF] = true;
zrxAllowlist[0x080bf510FCbF18b91105470639e9561022937712] = true;
nonPayableAddrs[0x080bf510FCbF18b91105470639e9561022937712] = true;
}
function setAllowlistAddr(address _zrxAddr, bool _state) public onlyOwner {
zrxAllowlist[_zrxAddr] = _state;
}
function isZrxAddr(address _zrxAddr) public view returns (bool) {
return zrxAllowlist[_zrxAddr];
}
function addNonPayableAddr(address _nonPayableAddr) public onlyOwner {
nonPayableAddrs[_nonPayableAddr] = true;
}
function removeNonPayableAddr(address _nonPayableAddr) public onlyOwner {
nonPayableAddrs[_nonPayableAddr] = false;
}
function isNonPayableAddr(address _addr) public view returns(bool) {
return nonPayableAddrs[_addr];
}
} contract Discount {
address public owner;
mapping(address => CustomServiceFee) public serviceFees;
uint256 constant MAX_SERVICE_FEE = 400;
struct CustomServiceFee {
bool active;
uint256 amount;
}
constructor() public {
owner = msg.sender;
}
function isCustomFeeSet(address _user) public view returns (bool) {
return serviceFees[_user].active;
}
function getCustomServiceFee(address _user) public view returns (uint256) {
return serviceFees[_user].amount;
}
function setServiceFee(address _user, uint256 _fee) public {
require(msg.sender == owner, "Only owner");
require(_fee >= MAX_SERVICE_FEE || _fee == 0);
serviceFees[_user] = CustomServiceFee({active: true, amount: _fee});
}
function disableServiceFee(address _user) public {
require(msg.sender == owner, "Only owner");
serviceFees[_user] = CustomServiceFee({active: false, amount: 0});
}
} contract SaverExchangeHelper {
using SafeERC20 for ERC20;
address public constant KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public constant WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address payable public constant WALLET_ID = 0x322d58b9E75a6918f7e7849AEe0fF09369977e08;
address public constant DISCOUNT_ADDRESS = 0x1b14E8D511c9A4395425314f849bD737BAF8208F;
address public constant SAVER_EXCHANGE_REGISTRY = 0x25dd3F51e0C3c3Ff164DDC02A8E4D65Bb9cBB12D;
address public constant ERC20_PROXY_0X = 0x95E6F48254609A6ee006F7D493c8e5fB97094ceF;
address public constant ZRX_ALLOWLIST_ADDR = 0x4BA1f38427b33B8ab7Bb0490200dAE1F1C36823F;
function getDecimals(address _token) internal view returns (uint256) {
if (_token == KYBER_ETH_ADDRESS) return 18;
return ERC20(_token).decimals();
}
function getBalance(address _tokenAddr) internal view returns (uint balance) {
if (_tokenAddr == KYBER_ETH_ADDRESS) {
balance = address(this).balance;
} else {
balance = ERC20(_tokenAddr).balanceOf(address(this));
}
}
function approve0xProxy(address _tokenAddr, uint _amount) internal {
if (_tokenAddr != KYBER_ETH_ADDRESS) {
ERC20(_tokenAddr).safeApprove(address(ERC20_PROXY_0X), _amount);
}
}
function sendLeftover(address _srcAddr, address _destAddr, address payable _to) internal {
// send back any leftover ether or tokens
if (address(this).balance > 0) {
_to.transfer(address(this).balance);
}
if (getBalance(_srcAddr) > 0) {
ERC20(_srcAddr).safeTransfer(_to, getBalance(_srcAddr));
}
if (getBalance(_destAddr) > 0) {
ERC20(_destAddr).safeTransfer(_to, getBalance(_destAddr));
}
}
function sliceUint(bytes memory bs, uint256 start) internal pure returns (uint256) {
require(bs.length >= start + 32, "slicing out of range");
uint256 x;
assembly {
x := mload(add(bs, add(0x20, start)))
}
return x;
}
} contract SaverExchangeRegistry is AdminAuth {
mapping(address => bool) private wrappers;
constructor() public {
wrappers[0x880A845A85F843a5c67DB2061623c6Fc3bB4c511] = true;
wrappers[0x4c9B55f2083629A1F7aDa257ae984E03096eCD25] = true;
wrappers[0x42A9237b872368E1bec4Ca8D26A928D7d39d338C] = true;
}
function addWrapper(address _wrapper) public onlyOwner {
wrappers[_wrapper] = true;
}
function removeWrapper(address _wrapper) public onlyOwner {
wrappers[_wrapper] = false;
}
function isWrapper(address _wrapper) public view returns(bool) {
return wrappers[_wrapper];
}
}
contract SaverExchangeCore is SaverExchangeHelper, DSMath {
// first is empty to keep the legacy order in place
enum ExchangeType { _, OASIS, KYBER, UNISWAP, ZEROX }
enum ActionType { SELL, BUY }
struct ExchangeData {
address srcAddr;
address destAddr;
uint srcAmount;
uint destAmount;
uint minPrice;
address wrapper;
address exchangeAddr;
bytes callData;
uint256 price0x;
}
/// @notice Internal method that preforms a sell on 0x/on-chain
/// @dev Usefull for other DFS contract to integrate for exchanging
/// @param exData Exchange data struct
/// @return (address, uint) Address of the wrapper used and destAmount
function _sell(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
uint tokensLeft = exData.srcAmount;
// if selling eth, convert to weth
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
// Try 0x first and then fallback on specific wrapper
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens, tokensLeft) = takeOrder(exData, ethAmount, ActionType.SELL);
if (success) {
wrapper = exData.exchangeAddr;
}
}
// fallback to desired wrapper if 0x failed
if (!success) {
swapedTokens = saverSwap(exData, ActionType.SELL);
wrapper = exData.wrapper;
}
require(getBalance(exData.destAddr) >= wmul(exData.minPrice, exData.srcAmount), "Final amount isn't correct");
// if anything is left in weth, pull it to user as eth
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, swapedTokens);
}
/// @notice Internal method that preforms a buy on 0x/on-chain
/// @dev Usefull for other DFS contract to integrate for exchanging
/// @param exData Exchange data struct
/// @return (address, uint) Address of the wrapper used and srcAmount
function _buy(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
require(exData.destAmount != 0, "Dest amount must be specified");
// if selling eth, convert to weth
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens,) = takeOrder(exData, ethAmount, ActionType.BUY);
if (success) {
wrapper = exData.exchangeAddr;
}
}
// fallback to desired wrapper if 0x failed
if (!success) {
swapedTokens = saverSwap(exData, ActionType.BUY);
wrapper = exData.wrapper;
}
require(swapedTokens >= exData.destAmount, "Final amount isn't correct");
// if anything is left in weth, pull it to user as eth
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, getBalance(exData.destAddr));
}
/// @notice Takes order from 0x and returns bool indicating if it is successful
/// @param _exData Exchange data
/// @param _ethAmount Ether fee needed for 0x order
function takeOrder(
ExchangeData memory _exData,
uint256 _ethAmount,
ActionType _type
) private returns (bool success, uint256, uint256) {
// write in the exact amount we are selling/buing in an order
if (_type == ActionType.SELL) {
writeUint256(_exData.callData, 36, _exData.srcAmount);
} else {
writeUint256(_exData.callData, 36, _exData.destAmount);
}
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isNonPayableAddr(_exData.exchangeAddr)) {
_ethAmount = 0;
}
uint256 tokensBefore = getBalance(_exData.destAddr);
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isZrxAddr(_exData.exchangeAddr)) {
(success, ) = _exData.exchangeAddr.call{value: _ethAmount}(_exData.callData);
} else {
success = false;
}
uint256 tokensSwaped = 0;
uint256 tokensLeft = _exData.srcAmount;
if (success) {
// check to see if any _src tokens are left over after exchange
tokensLeft = getBalance(_exData.srcAddr);
// convert weth -> eth if needed
if (_exData.destAddr == KYBER_ETH_ADDRESS) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
// get the current balance of the swaped tokens
tokensSwaped = getBalance(_exData.destAddr) - tokensBefore;
}
return (success, tokensSwaped, tokensLeft);
}
/// @notice Calls wraper contract for exchage to preform an on-chain swap
/// @param _exData Exchange data struct
/// @param _type Type of action SELL|BUY
/// @return swapedTokens For Sell that the destAmount, for Buy thats the srcAmount
function saverSwap(ExchangeData memory _exData, ActionType _type) internal returns (uint swapedTokens) {
require(SaverExchangeRegistry(SAVER_EXCHANGE_REGISTRY).isWrapper(_exData.wrapper), "Wrapper is not valid");
uint ethValue = 0;
ERC20(_exData.srcAddr).safeTransfer(_exData.wrapper, _exData.srcAmount);
if (_type == ActionType.SELL) {
swapedTokens = ExchangeInterfaceV2(_exData.wrapper).
sell{value: ethValue}(_exData.srcAddr, _exData.destAddr, _exData.srcAmount);
} else {
swapedTokens = ExchangeInterfaceV2(_exData.wrapper).
buy{value: ethValue}(_exData.srcAddr, _exData.destAddr, _exData.destAmount);
}
}
function writeUint256(bytes memory _b, uint256 _index, uint _input) internal pure {
if (_b.length < _index + 32) {
revert("Incorrent lengt while writting bytes32");
}
bytes32 input = bytes32(_input);
_index += 32;
// Read the bytes32 from array memory
assembly {
mstore(add(_b, _index), input)
}
}
/// @notice Converts Kybers Eth address -> Weth
/// @param _src Input address
function ethToWethAddr(address _src) internal pure returns (address) {
return _src == KYBER_ETH_ADDRESS ? WETH_ADDRESS : _src;
}
function packExchangeData(ExchangeData memory _exData) public pure returns(bytes memory) {
// splitting in two different bytes and encoding all because of stack too deep in decoding part
bytes memory part1 = abi.encode(
_exData.srcAddr,
_exData.destAddr,
_exData.srcAmount,
_exData.destAmount
);
bytes memory part2 = abi.encode(
_exData.minPrice,
_exData.wrapper,
_exData.exchangeAddr,
_exData.callData,
_exData.price0x
);
return abi.encode(part1, part2);
}
function unpackExchangeData(bytes memory _data) public pure returns(ExchangeData memory _exData) {
(
bytes memory part1,
bytes memory part2
) = abi.decode(_data, (bytes,bytes));
(
_exData.srcAddr,
_exData.destAddr,
_exData.srcAmount,
_exData.destAmount
) = abi.decode(part1, (address,address,uint256,uint256));
(
_exData.minPrice,
_exData.wrapper,
_exData.exchangeAddr,
_exData.callData,
_exData.price0x
)
= abi.decode(part2, (uint256,address,address,bytes,uint256));
}
// solhint-disable-next-line no-empty-blocks
receive() external virtual payable {}
}
/// @title Contract that receives the FL from Aave for Repays/Boost
contract CompoundSaverFlashLoan is FlashLoanReceiverBase, SaverExchangeCore {
ILendingPoolAddressesProvider public LENDING_POOL_ADDRESS_PROVIDER = ILendingPoolAddressesProvider(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
address payable public COMPOUND_SAVER_FLASH_PROXY = 0xcEAb38B5C88F33Dabe4D31BDD384E08215526632;
address public constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public owner;
using SafeERC20 for ERC20;
constructor()
FlashLoanReceiverBase(LENDING_POOL_ADDRESS_PROVIDER)
public {
owner = msg.sender;
}
/// @notice Called by Aave when sending back the FL amount
/// @param _reserve The address of the borrowed token
/// @param _amount Amount of FL tokens received
/// @param _fee FL Aave fee
/// @param _params The params that are sent from the original FL caller contract
function executeOperation(
address _reserve,
uint256 _amount,
uint256 _fee,
bytes calldata _params)
external override {
// Format the call data for DSProxy
(bytes memory proxyData, address payable proxyAddr) = packFunctionCall(_amount, _fee, _params);
// Send Flash loan amount to DSProxy
sendLoanToProxy(proxyAddr, _reserve, _amount);
// Execute the DSProxy call
DSProxyInterface(proxyAddr).execute(COMPOUND_SAVER_FLASH_PROXY, proxyData);
// Repay the loan with the money DSProxy sent back
transferFundsBackToPoolInternal(_reserve, _amount.add(_fee));
// if there is some eth left (0x fee), return it to user
if (address(this).balance > 0) {
tx.origin.transfer(address(this).balance);
}
}
/// @notice Formats function data call so we can call it through DSProxy
/// @param _amount Amount of FL
/// @param _fee Fee of the FL
/// @param _params Saver proxy params
/// @return proxyData Formated function call data
function packFunctionCall(uint _amount, uint _fee, bytes memory _params) internal pure returns (bytes memory proxyData, address payable) {
(
bytes memory exDataBytes,
address[2] memory cAddresses, // cCollAddress, cBorrowAddress
uint256 gasCost,
bool isRepay,
address payable proxyAddr
)
= abi.decode(_params, (bytes,address[2],uint256,bool,address));
ExchangeData memory _exData = unpackExchangeData(exDataBytes);
uint[2] memory flashLoanData = [_amount, _fee];
if (isRepay) {
proxyData = abi.encodeWithSignature("flashRepay((address,address,uint256,uint256,uint256,address,address,bytes,uint256),address[2],uint256,uint256[2])", _exData, cAddresses, gasCost, flashLoanData);
} else {
proxyData = abi.encodeWithSignature("flashBoost((address,address,uint256,uint256,uint256,address,address,bytes,uint256),address[2],uint256,uint256[2])", _exData, cAddresses, gasCost, flashLoanData);
}
return (proxyData, proxyAddr);
}
/// @notice Send the FL funds received to DSProxy
/// @param _proxy DSProxy address
/// @param _reserve Token address
/// @param _amount Amount of tokens
function sendLoanToProxy(address payable _proxy, address _reserve, uint _amount) internal {
if (_reserve != ETH_ADDRESS) {
ERC20(_reserve).safeTransfer(_proxy, _amount);
}
_proxy.transfer(address(this).balance);
}
receive() external override(SaverExchangeCore, FlashLoanReceiverBase) payable {}
} | first is empty to keep the legacy order in place | contract SaverExchangeCore is SaverExchangeHelper, DSMath {
enum ExchangeType { _, OASIS, KYBER, UNISWAP, ZEROX }
enum ActionType { SELL, BUY }
struct ExchangeData {
address srcAddr;
address destAddr;
uint srcAmount;
uint destAmount;
uint minPrice;
address wrapper;
address exchangeAddr;
bytes callData;
uint256 price0x;
}
function _sell(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
uint tokensLeft = exData.srcAmount;
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens, tokensLeft) = takeOrder(exData, ethAmount, ActionType.SELL);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.SELL);
wrapper = exData.wrapper;
}
require(getBalance(exData.destAddr) >= wmul(exData.minPrice, exData.srcAmount), "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, swapedTokens);
}
function _sell(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
uint tokensLeft = exData.srcAmount;
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens, tokensLeft) = takeOrder(exData, ethAmount, ActionType.SELL);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.SELL);
wrapper = exData.wrapper;
}
require(getBalance(exData.destAddr) >= wmul(exData.minPrice, exData.srcAmount), "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, swapedTokens);
}
function _sell(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
uint tokensLeft = exData.srcAmount;
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens, tokensLeft) = takeOrder(exData, ethAmount, ActionType.SELL);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.SELL);
wrapper = exData.wrapper;
}
require(getBalance(exData.destAddr) >= wmul(exData.minPrice, exData.srcAmount), "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, swapedTokens);
}
function _sell(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
uint tokensLeft = exData.srcAmount;
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens, tokensLeft) = takeOrder(exData, ethAmount, ActionType.SELL);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.SELL);
wrapper = exData.wrapper;
}
require(getBalance(exData.destAddr) >= wmul(exData.minPrice, exData.srcAmount), "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, swapedTokens);
}
function _sell(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
uint tokensLeft = exData.srcAmount;
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens, tokensLeft) = takeOrder(exData, ethAmount, ActionType.SELL);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.SELL);
wrapper = exData.wrapper;
}
require(getBalance(exData.destAddr) >= wmul(exData.minPrice, exData.srcAmount), "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, swapedTokens);
}
function _sell(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
uint tokensLeft = exData.srcAmount;
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens, tokensLeft) = takeOrder(exData, ethAmount, ActionType.SELL);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.SELL);
wrapper = exData.wrapper;
}
require(getBalance(exData.destAddr) >= wmul(exData.minPrice, exData.srcAmount), "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, swapedTokens);
}
function _buy(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
require(exData.destAmount != 0, "Dest amount must be specified");
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens,) = takeOrder(exData, ethAmount, ActionType.BUY);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.BUY);
wrapper = exData.wrapper;
}
require(swapedTokens >= exData.destAmount, "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, getBalance(exData.destAddr));
}
function _buy(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
require(exData.destAmount != 0, "Dest amount must be specified");
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens,) = takeOrder(exData, ethAmount, ActionType.BUY);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.BUY);
wrapper = exData.wrapper;
}
require(swapedTokens >= exData.destAmount, "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, getBalance(exData.destAddr));
}
function _buy(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
require(exData.destAmount != 0, "Dest amount must be specified");
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens,) = takeOrder(exData, ethAmount, ActionType.BUY);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.BUY);
wrapper = exData.wrapper;
}
require(swapedTokens >= exData.destAmount, "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, getBalance(exData.destAddr));
}
function _buy(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
require(exData.destAmount != 0, "Dest amount must be specified");
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens,) = takeOrder(exData, ethAmount, ActionType.BUY);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.BUY);
wrapper = exData.wrapper;
}
require(swapedTokens >= exData.destAmount, "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, getBalance(exData.destAddr));
}
function _buy(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
require(exData.destAmount != 0, "Dest amount must be specified");
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens,) = takeOrder(exData, ethAmount, ActionType.BUY);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.BUY);
wrapper = exData.wrapper;
}
require(swapedTokens >= exData.destAmount, "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, getBalance(exData.destAddr));
}
function _buy(ExchangeData memory exData) internal returns (address, uint) {
address wrapper;
uint swapedTokens;
bool success;
require(exData.destAmount != 0, "Dest amount must be specified");
if (exData.srcAddr == KYBER_ETH_ADDRESS) {
exData.srcAddr = ethToWethAddr(exData.srcAddr);
TokenInterface(WETH_ADDRESS).deposit.value(exData.srcAmount)();
}
if (exData.price0x > 0) {
approve0xProxy(exData.srcAddr, exData.srcAmount);
uint ethAmount = exData.srcAddr == WETH_ADDRESS ? msg.value - exData.srcAmount : msg.value;
(success, swapedTokens,) = takeOrder(exData, ethAmount, ActionType.BUY);
if (success) {
wrapper = exData.exchangeAddr;
}
}
if (!success) {
swapedTokens = saverSwap(exData, ActionType.BUY);
wrapper = exData.wrapper;
}
require(swapedTokens >= exData.destAmount, "Final amount isn't correct");
if (getBalance(WETH_ADDRESS) > 0) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
return (wrapper, getBalance(exData.destAddr));
}
function takeOrder(
ExchangeData memory _exData,
uint256 _ethAmount,
ActionType _type
) private returns (bool success, uint256, uint256) {
if (_type == ActionType.SELL) {
writeUint256(_exData.callData, 36, _exData.srcAmount);
writeUint256(_exData.callData, 36, _exData.destAmount);
}
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isNonPayableAddr(_exData.exchangeAddr)) {
_ethAmount = 0;
}
uint256 tokensBefore = getBalance(_exData.destAddr);
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isZrxAddr(_exData.exchangeAddr)) {
success = false;
}
uint256 tokensSwaped = 0;
uint256 tokensLeft = _exData.srcAmount;
if (success) {
tokensLeft = getBalance(_exData.srcAddr);
if (_exData.destAddr == KYBER_ETH_ADDRESS) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
}
return (success, tokensSwaped, tokensLeft);
}
function takeOrder(
ExchangeData memory _exData,
uint256 _ethAmount,
ActionType _type
) private returns (bool success, uint256, uint256) {
if (_type == ActionType.SELL) {
writeUint256(_exData.callData, 36, _exData.srcAmount);
writeUint256(_exData.callData, 36, _exData.destAmount);
}
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isNonPayableAddr(_exData.exchangeAddr)) {
_ethAmount = 0;
}
uint256 tokensBefore = getBalance(_exData.destAddr);
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isZrxAddr(_exData.exchangeAddr)) {
success = false;
}
uint256 tokensSwaped = 0;
uint256 tokensLeft = _exData.srcAmount;
if (success) {
tokensLeft = getBalance(_exData.srcAddr);
if (_exData.destAddr == KYBER_ETH_ADDRESS) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
}
return (success, tokensSwaped, tokensLeft);
}
} else {
function takeOrder(
ExchangeData memory _exData,
uint256 _ethAmount,
ActionType _type
) private returns (bool success, uint256, uint256) {
if (_type == ActionType.SELL) {
writeUint256(_exData.callData, 36, _exData.srcAmount);
writeUint256(_exData.callData, 36, _exData.destAmount);
}
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isNonPayableAddr(_exData.exchangeAddr)) {
_ethAmount = 0;
}
uint256 tokensBefore = getBalance(_exData.destAddr);
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isZrxAddr(_exData.exchangeAddr)) {
success = false;
}
uint256 tokensSwaped = 0;
uint256 tokensLeft = _exData.srcAmount;
if (success) {
tokensLeft = getBalance(_exData.srcAddr);
if (_exData.destAddr == KYBER_ETH_ADDRESS) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
}
return (success, tokensSwaped, tokensLeft);
}
function takeOrder(
ExchangeData memory _exData,
uint256 _ethAmount,
ActionType _type
) private returns (bool success, uint256, uint256) {
if (_type == ActionType.SELL) {
writeUint256(_exData.callData, 36, _exData.srcAmount);
writeUint256(_exData.callData, 36, _exData.destAmount);
}
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isNonPayableAddr(_exData.exchangeAddr)) {
_ethAmount = 0;
}
uint256 tokensBefore = getBalance(_exData.destAddr);
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isZrxAddr(_exData.exchangeAddr)) {
success = false;
}
uint256 tokensSwaped = 0;
uint256 tokensLeft = _exData.srcAmount;
if (success) {
tokensLeft = getBalance(_exData.srcAddr);
if (_exData.destAddr == KYBER_ETH_ADDRESS) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
}
return (success, tokensSwaped, tokensLeft);
}
(success, ) = _exData.exchangeAddr.call{value: _ethAmount}(_exData.callData);
} else {
function takeOrder(
ExchangeData memory _exData,
uint256 _ethAmount,
ActionType _type
) private returns (bool success, uint256, uint256) {
if (_type == ActionType.SELL) {
writeUint256(_exData.callData, 36, _exData.srcAmount);
writeUint256(_exData.callData, 36, _exData.destAmount);
}
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isNonPayableAddr(_exData.exchangeAddr)) {
_ethAmount = 0;
}
uint256 tokensBefore = getBalance(_exData.destAddr);
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isZrxAddr(_exData.exchangeAddr)) {
success = false;
}
uint256 tokensSwaped = 0;
uint256 tokensLeft = _exData.srcAmount;
if (success) {
tokensLeft = getBalance(_exData.srcAddr);
if (_exData.destAddr == KYBER_ETH_ADDRESS) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
}
return (success, tokensSwaped, tokensLeft);
}
function takeOrder(
ExchangeData memory _exData,
uint256 _ethAmount,
ActionType _type
) private returns (bool success, uint256, uint256) {
if (_type == ActionType.SELL) {
writeUint256(_exData.callData, 36, _exData.srcAmount);
writeUint256(_exData.callData, 36, _exData.destAmount);
}
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isNonPayableAddr(_exData.exchangeAddr)) {
_ethAmount = 0;
}
uint256 tokensBefore = getBalance(_exData.destAddr);
if (ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isZrxAddr(_exData.exchangeAddr)) {
success = false;
}
uint256 tokensSwaped = 0;
uint256 tokensLeft = _exData.srcAmount;
if (success) {
tokensLeft = getBalance(_exData.srcAddr);
if (_exData.destAddr == KYBER_ETH_ADDRESS) {
TokenInterface(WETH_ADDRESS).withdraw(
TokenInterface(WETH_ADDRESS).balanceOf(address(this))
);
}
}
return (success, tokensSwaped, tokensLeft);
}
tokensSwaped = getBalance(_exData.destAddr) - tokensBefore;
function saverSwap(ExchangeData memory _exData, ActionType _type) internal returns (uint swapedTokens) {
require(SaverExchangeRegistry(SAVER_EXCHANGE_REGISTRY).isWrapper(_exData.wrapper), "Wrapper is not valid");
uint ethValue = 0;
ERC20(_exData.srcAddr).safeTransfer(_exData.wrapper, _exData.srcAmount);
if (_type == ActionType.SELL) {
swapedTokens = ExchangeInterfaceV2(_exData.wrapper).
swapedTokens = ExchangeInterfaceV2(_exData.wrapper).
}
}
function saverSwap(ExchangeData memory _exData, ActionType _type) internal returns (uint swapedTokens) {
require(SaverExchangeRegistry(SAVER_EXCHANGE_REGISTRY).isWrapper(_exData.wrapper), "Wrapper is not valid");
uint ethValue = 0;
ERC20(_exData.srcAddr).safeTransfer(_exData.wrapper, _exData.srcAmount);
if (_type == ActionType.SELL) {
swapedTokens = ExchangeInterfaceV2(_exData.wrapper).
swapedTokens = ExchangeInterfaceV2(_exData.wrapper).
}
}
sell{value: ethValue}(_exData.srcAddr, _exData.destAddr, _exData.srcAmount);
} else {
buy{value: ethValue}(_exData.srcAddr, _exData.destAddr, _exData.destAmount);
function writeUint256(bytes memory _b, uint256 _index, uint _input) internal pure {
if (_b.length < _index + 32) {
revert("Incorrent lengt while writting bytes32");
}
bytes32 input = bytes32(_input);
_index += 32;
assembly {
mstore(add(_b, _index), input)
}
}
function writeUint256(bytes memory _b, uint256 _index, uint _input) internal pure {
if (_b.length < _index + 32) {
revert("Incorrent lengt while writting bytes32");
}
bytes32 input = bytes32(_input);
_index += 32;
assembly {
mstore(add(_b, _index), input)
}
}
function writeUint256(bytes memory _b, uint256 _index, uint _input) internal pure {
if (_b.length < _index + 32) {
revert("Incorrent lengt while writting bytes32");
}
bytes32 input = bytes32(_input);
_index += 32;
assembly {
mstore(add(_b, _index), input)
}
}
function ethToWethAddr(address _src) internal pure returns (address) {
return _src == KYBER_ETH_ADDRESS ? WETH_ADDRESS : _src;
}
function packExchangeData(ExchangeData memory _exData) public pure returns(bytes memory) {
bytes memory part1 = abi.encode(
_exData.srcAddr,
_exData.destAddr,
_exData.srcAmount,
_exData.destAmount
);
bytes memory part2 = abi.encode(
_exData.minPrice,
_exData.wrapper,
_exData.exchangeAddr,
_exData.callData,
_exData.price0x
);
return abi.encode(part1, part2);
}
function unpackExchangeData(bytes memory _data) public pure returns(ExchangeData memory _exData) {
(
bytes memory part1,
bytes memory part2
) = abi.decode(_data, (bytes,bytes));
(
_exData.srcAddr,
_exData.destAddr,
_exData.srcAmount,
_exData.destAmount
) = abi.decode(part1, (address,address,uint256,uint256));
(
_exData.minPrice,
_exData.wrapper,
_exData.exchangeAddr,
_exData.callData,
_exData.price0x
)
= abi.decode(part2, (uint256,address,address,bytes,uint256));
}
receive() external virtual payable {}
}
| 14,442,724 | [
1,
3645,
353,
1008,
358,
3455,
326,
8866,
1353,
316,
3166,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
16351,
348,
21851,
11688,
4670,
353,
348,
21851,
11688,
2276,
16,
463,
7303,
421,
288,
203,
203,
203,
203,
565,
2792,
18903,
559,
288,
389,
16,
531,
37,
15664,
16,
1475,
61,
6271,
16,
5019,
5127,
59,
2203,
16,
18449,
60,
289,
203,
565,
2792,
4382,
559,
288,
20853,
48,
16,
10937,
61,
289,
203,
565,
1958,
18903,
751,
288,
203,
3639,
1758,
1705,
3178,
31,
203,
3639,
1758,
1570,
3178,
31,
203,
3639,
2254,
1705,
6275,
31,
203,
3639,
2254,
1570,
6275,
31,
203,
3639,
2254,
1131,
5147,
31,
203,
3639,
1758,
4053,
31,
203,
3639,
1758,
7829,
3178,
31,
203,
3639,
1731,
745,
751,
31,
203,
3639,
2254,
5034,
6205,
20,
92,
31,
203,
565,
289,
203,
203,
565,
445,
389,
87,
1165,
12,
11688,
751,
3778,
431,
751,
13,
2713,
1135,
261,
2867,
16,
2254,
13,
288,
203,
203,
3639,
1758,
4053,
31,
203,
3639,
2254,
1352,
5994,
5157,
31,
203,
3639,
1426,
2216,
31,
203,
3639,
2254,
2430,
3910,
273,
431,
751,
18,
4816,
6275,
31,
203,
203,
3639,
309,
261,
338,
751,
18,
4816,
3178,
422,
1475,
61,
6271,
67,
1584,
44,
67,
15140,
13,
288,
203,
5411,
431,
751,
18,
4816,
3178,
273,
13750,
774,
59,
546,
3178,
12,
338,
751,
18,
4816,
3178,
1769,
203,
5411,
29938,
12,
59,
1584,
44,
67,
15140,
2934,
323,
1724,
18,
1132,
12,
338,
751,
18,
4816,
6275,
13,
5621,
203,
3639,
289,
203,
203,
3639,
309,
261,
338,
751,
18,
8694,
20,
92,
405,
374,
13,
288,
203,
5411,
6617,
2
] |
./partial_match/3/0xe1A09c422724371FFd84Ac3cA53A77eE7117fb06/sources/RigelGift.sol | Mapping of the ProjectReward and its information | mapping(uint256 => RewardProject) public rewardProjMapping;
| 5,052,852 | [
1,
3233,
434,
326,
5420,
17631,
1060,
471,
2097,
1779,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
2874,
12,
11890,
5034,
516,
534,
359,
1060,
4109,
13,
1071,
19890,
626,
78,
3233,
31,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/42220/0xae79cd37ac9b2f7bb5272C098c787Ae4A0c17df5/sources/contracts/microcredit/interfaces/IMicrocredit.sol | address managerAddress; | struct LoanOld {
uint256 amountBorrowed;
uint256 dailyInterest;
uint256 claimDeadline;
uint256 lastComputedDebt;
uint256 amountRepayed;
Repayment[] repayments;
uint256 lastComputedDate;
}
| 16,319,685 | [
1,
2867,
3301,
1887,
31,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
1958,
3176,
304,
7617,
288,
203,
3639,
2254,
5034,
3844,
38,
15318,
329,
31,
203,
3639,
2254,
5034,
18872,
29281,
31,
203,
3639,
2254,
5034,
7516,
15839,
31,
203,
3639,
2254,
5034,
1142,
17934,
758,
23602,
31,
203,
3639,
2254,
5034,
3844,
426,
10239,
329,
31,
203,
3639,
868,
9261,
8526,
2071,
528,
1346,
31,
203,
3639,
2254,
5034,
1142,
17934,
1626,
31,
203,
565,
289,
203,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
import "../DS/DSMath.sol";
import "../interfaces/mcd/IManager.sol";
import "../interfaces/mcd/ISpotter.sol";
import "../interfaces/mcd/IVat.sol";
/// @title Getter contract for Vault info from Maker protocol
contract McdView is DSMath {
address public constant MANAGER_ADDRESS = 0x5ef30b9986345249bc32d8928B7ee64DE9435E39;
address public constant VAT_ADDRESS = 0x35D1b3F3D7966A1DFe207aa4514C12a259A0492B;
address public constant SPOTTER_ADDRESS = 0x65C79fcB50Ca1594B025960e539eD7A9a6D434A3;
IManager public constant manager = IManager(MANAGER_ADDRESS);
IVat public constant vat = IVat(VAT_ADDRESS);
ISpotter public constant spotter = ISpotter(SPOTTER_ADDRESS);
/// @notice Gets Vault info (collateral, debt)
/// @param _vaultId Id of the Vault
/// @param _ilk Ilk of the Vault
function getVaultInfo(uint _vaultId, bytes32 _ilk) public view returns (uint, uint) {
address urn = manager.urns(_vaultId);
(uint collateral, uint debt) = vat.urns(_ilk, urn);
(,uint rate,,,) = vat.ilks(_ilk);
return (collateral, rmul(debt, rate));
}
/// @notice Gets a price of the asset
/// @param _ilk Ilk of the Vault
function getPrice(bytes32 _ilk) public view returns (uint) {
(, uint mat) = spotter.ilks(_ilk);
(,,uint spot,,) = vat.ilks(_ilk);
return rmul(rmul(spot, spotter.par()), mat);
}
/// @notice Gets Vaults ratio
/// @param _vaultId Id of the Vault
function getRatio(uint _vaultId) public view returns (uint) {
bytes32 ilk = manager.ilks(_vaultId);
uint price = getPrice(ilk);
(uint collateral, uint debt) = getVaultInfo(_vaultId, ilk);
if (debt == 0) return 0;
return rdiv(wmul(collateral, price), debt) / (10 ** 18);
}
} | @notice Gets Vaults ratio @param _vaultId Id of the Vault | function getRatio(uint _vaultId) public view returns (uint) {
bytes32 ilk = manager.ilks(_vaultId);
uint price = getPrice(ilk);
(uint collateral, uint debt) = getVaultInfo(_vaultId, ilk);
if (debt == 0) return 0;
return rdiv(wmul(collateral, price), debt) / (10 ** 18);
}
| 6,410,928 | [
1,
3002,
17329,
87,
7169,
225,
389,
26983,
548,
3124,
434,
326,
17329,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
4170,
4197,
12,
11890,
389,
26983,
548,
13,
1071,
1476,
1135,
261,
11890,
13,
288,
203,
3639,
1731,
1578,
14254,
79,
273,
3301,
18,
330,
7904,
24899,
26983,
548,
1769,
203,
3639,
2254,
6205,
273,
25930,
12,
330,
79,
1769,
203,
203,
3639,
261,
11890,
4508,
2045,
287,
16,
2254,
18202,
88,
13,
273,
11031,
3714,
966,
24899,
26983,
548,
16,
14254,
79,
1769,
203,
203,
3639,
309,
261,
323,
23602,
422,
374,
13,
327,
374,
31,
203,
203,
3639,
327,
436,
2892,
12,
91,
16411,
12,
12910,
2045,
287,
16,
6205,
3631,
18202,
88,
13,
342,
261,
2163,
2826,
6549,
1769,
203,
565,
289,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity 0.5.1;
/**
* @dev Base contract for teams
*/
contract CryptoTeam {
using SafeMath for uint256;
//Developers fund
address payable public teamAddressOne ; //inject UNINIT LOCAL/STATE VAR
address payable public teamAddressTwo ; //inject UNINIT LOCAL/STATE VAR
address payable public teamAddressThree ; //inject UNINIT LOCAL/STATE VAR
Bank public BankContract;
CBCToken public CBCTokenContract;
/**
* @dev Payable function. 10% will send to Developers fund and 90% will send to JackPot contract.
* Also setting info about player.
*/
function () external payable {
require(BankContract.getState() && msg.value >= 0.05 ether);
BankContract.setInfo(msg.sender, msg.value.mul(90).div(100));
teamAddressOne.transfer(msg.value.mul(4).div(100));
teamAddressTwo.transfer(msg.value.mul(4).div(100));
teamAddressThree.transfer(msg.value.mul(2).div(100));
address(BankContract).transfer(msg.value.mul(90).div(100));
}
}
/*
* @dev Bears contract. To play game with Bears send ETH to this contract
*/
contract Bears is CryptoTeam {
constructor(address payable _bankAddress, address payable _CBCTokenAddress) public {
BankContract = Bank(_bankAddress);
BankContract.setBearsAddress(address(this));
CBCTokenContract = CBCToken(_CBCTokenAddress);
CBCTokenContract.approve(_bankAddress, 9999999999999999999000000000000000000);
}
}
/*
* @dev Bulls contract. To play game with Bulls send ETH to this contract
*/
contract Bulls is CryptoTeam {
constructor(address payable _bankAddress, address payable _CBCTokenAddress) public {
BankContract = Bank(_bankAddress);
BankContract.setBullsAddress(address(this));
CBCTokenContract = CBCToken(_CBCTokenAddress);
CBCTokenContract.approve(_bankAddress, 9999999999999999999000000000000000000);
}
}
/*
* @title Bank
* @dev Bank contract which contained all ETH from Dragons and Hamsters teams.
* When time in blockchain will be grater then current deadline or last deadline need call getWinner function
* then participants able get prizes.
*
* Last participant(last hero) win 10% from all bank
*
* - To get prize send 0 ETH to this contract
*/
contract Bank {
using SafeMath for uint256;
mapping (address => uint256) public depositBears;
mapping (address => uint256) public depositBulls;
uint256 public currentDeadline;
uint256 public lastDeadline ; //inject UNINIT LOCAL/STATE VAR
uint256 public countOfBears;
uint256 public countOfBulls;
uint256 public totalSupplyOfBulls;
uint256 public totalSupplyOfBears;
uint256 public totalCBCSupplyOfBulls;
uint256 public totalCBCSupplyOfBears;
uint256 public probabilityOfBulls;
uint256 public probabilityOfBears;
address public lastHero;
address public lastHeroHistory;
uint256 public jackPot;
uint256 public winner;
bool public finished ; //inject UNINIT LOCAL/STATE VAR
Bears public BearsContract;
Bulls public BullsContract;
CBCToken public CBCTokenContract;
/*
* @dev Constructor create first deadline
*/
constructor() public {
currentDeadline = block.timestamp + 60 * 60 * 24 * 3;
}
/**
* @dev Setter the CryptoBossCoin contract address. Address can be set at once.
* @param _CBCTokenAddress Address of the CryptoBossCoin contract
*/
function setCBCTokenAddress(address _CBCTokenAddress) public {
require(address(CBCTokenContract) == address(0x0));
CBCTokenContract = CBCToken(_CBCTokenAddress);
}
/**
* @dev Setter the Bears contract address. Address can be set at once.
* @param _bearsAddress Address of the Bears contract
*/
function setBearsAddress(address payable _bearsAddress) external {
require(address(BearsContract) == address(0x0));
BearsContract = Bears(_bearsAddress);
}
/**
* @dev Setter the Bulls contract address. Address can be set at once.
* @param _bullsAddress Address of the Bulls contract
*/
function setBullsAddress(address payable _bullsAddress) external {
require(address(BullsContract) == address(0x0));
BullsContract = Bulls(_bullsAddress);
}
/**
* @dev Getting time from blockchain for timer
*/
function getNow() view public returns(uint){
return block.timestamp;
}
/**
* @dev Getting state of game. True - game continue, False - game stopped
*/
function getState() view public returns(bool) {
if (block.timestamp > currentDeadline) {
return false;
}
return true;
}
/**
* @dev Setting info about participant from Bears or Bulls contract
* @param _lastHero Address of participant
* @param _deposit Amount of deposit
*/
function setInfo(address _lastHero, uint256 _deposit) public {
require(address(BearsContract) == msg.sender || address(BullsContract) == msg.sender);
if (address(BearsContract) == msg.sender) {
require(depositBulls[_lastHero] == 0, "You are already in bulls team");
if (depositBears[_lastHero] == 0)
countOfBears++;
totalSupplyOfBears = totalSupplyOfBears.add(_deposit.mul(90).div(100));
depositBears[_lastHero] = depositBears[_lastHero].add(_deposit.mul(90).div(100));
}
if (address(BullsContract) == msg.sender) {
require(depositBears[_lastHero] == 0, "You are already in bears team");
if (depositBulls[_lastHero] == 0)
countOfBulls++;
totalSupplyOfBulls = totalSupplyOfBulls.add(_deposit.mul(90).div(100));
depositBulls[_lastHero] = depositBulls[_lastHero].add(_deposit.mul(90).div(100));
}
lastHero = _lastHero;
if (currentDeadline.add(120) <= lastDeadline) {
currentDeadline = currentDeadline.add(120);
} else {
currentDeadline = lastDeadline;
}
jackPot = (address(this).balance.add(_deposit)).mul(10).div(100);
calculateProbability();
}
/**
* @dev Calculation probability for team's win
*/
function calculateProbability() public {
require(winner == 0 && getState());
totalCBCSupplyOfBulls = CBCTokenContract.balanceOf(address(BullsContract));
totalCBCSupplyOfBears = CBCTokenContract.balanceOf(address(BearsContract));
uint256 percent ; //inject UNINIT LOCAL/STATE VAR
if (totalCBCSupplyOfBulls < 1 ether) {
totalCBCSupplyOfBulls = 0;
}
if (totalCBCSupplyOfBears < 1 ether) {
totalCBCSupplyOfBears = 0;
}
if (totalCBCSupplyOfBulls <= totalCBCSupplyOfBears) {
uint256 difference ; //inject UNINIT LOCAL/STATE VAR
probabilityOfBears = totalSupplyOfBears.mul(100).div(percent).add(difference);
if (probabilityOfBears > 8000) {
probabilityOfBears = 8000;
}
if (probabilityOfBears < 2000) {
probabilityOfBears = 2000;
}
probabilityOfBulls = 10000 - probabilityOfBears;
} else {
uint256 difference ; //inject UNINIT LOCAL/STATE VAR
probabilityOfBulls = totalSupplyOfBulls.mul(100).div(percent).add(difference);
if (probabilityOfBulls > 8000) {
probabilityOfBulls = 8000;
}
if (probabilityOfBulls < 2000) {
probabilityOfBulls = 2000;
}
probabilityOfBears = 10000 - probabilityOfBulls;
}
totalCBCSupplyOfBulls = CBCTokenContract.balanceOf(address(BullsContract));
totalCBCSupplyOfBears = CBCTokenContract.balanceOf(address(BearsContract));
}
/**
* @dev Getting winner team
*/
function getWinners() public {
require(winner == 0 && !getState());
uint256 seed1 ; //inject UNINIT LOCAL/STATE VAR
uint256 seed2 ; //inject UNINIT LOCAL/STATE VAR
uint256 seed3 ; //inject UNINIT LOCAL/STATE VAR
uint256 seed4 ; //inject UNINIT LOCAL/STATE VAR
uint256 seed5 ; //inject UNINIT LOCAL/STATE VAR
uint256 seed6 ; //inject UNINIT LOCAL/STATE VAR
uint256 seed7 ; //inject UNINIT LOCAL/STATE VAR
bytes32 randomHash ; //inject UNINIT LOCAL/STATE VAR
uint randomNumber ; //inject UNINIT LOCAL/STATE VAR
if (randomNumber == 0){
randomNumber = 1;
}
uint winningNumber ; //inject UNINIT LOCAL/STATE VAR
if (1 <= winningNumber && winningNumber <= probabilityOfBears){
winner = 1;
}
if (probabilityOfBears < winningNumber && winningNumber <= 10000){
winner = 2;
}
}
/**
* @dev Payable function for take prize
*/
function () external payable {
if (msg.value == 0 && !getState() && winner > 0){
require(depositBears[msg.sender] > 0 || depositBulls[msg.sender] > 0);
uint payout ; //inject UNINIT LOCAL/STATE VAR
uint payoutCBC ; //inject UNINIT LOCAL/STATE VAR
if (winner == 1 && depositBears[msg.sender] > 0) {
payout = calculateETHPrize(msg.sender);
}
if (winner == 2 && depositBulls[msg.sender] > 0) {
payout = calculateETHPrize(msg.sender);
}
if (payout > 0) {
depositBears[msg.sender] = 0;
depositBulls[msg.sender] = 0;
msg.sender.transfer(payout);
}
if ((winner == 1 && depositBears[msg.sender] == 0) || (winner == 2 && depositBulls[msg.sender] == 0)) {
payoutCBC = calculateCBCPrize(msg.sender);
if (CBCTokenContract.balanceOf(address(BullsContract)) > 0)
CBCTokenContract.transferFrom(
address(BullsContract),
address(this),
CBCTokenContract.balanceOf(address(BullsContract))
);
if (CBCTokenContract.balanceOf(address(BearsContract)) > 0)
CBCTokenContract.transferFrom(
address(BearsContract),
address(this),
CBCTokenContract.balanceOf(address(BearsContract))
);
CBCTokenContract.transfer(msg.sender, payoutCBC);
}
if (msg.sender == lastHero) {
lastHeroHistory = lastHero;
lastHero = address(0x0);
msg.sender.transfer(jackPot);
}
}
}
/**
* @dev Getting ETH prize of participant
* @param participant Address of participant
*/
function calculateETHPrize(address participant) public view returns(uint) {
uint payout ; //inject UNINIT LOCAL/STATE VAR
uint256 totalSupply ; //inject UNINIT LOCAL/STATE VAR
if (depositBears[participant] > 0) {
payout = totalSupply.mul(depositBears[participant]).div(totalSupplyOfBears);
}
if (depositBulls[participant] > 0) {
payout = totalSupply.mul(depositBulls[participant]).div(totalSupplyOfBulls);
}
return payout;
}
/**
* @dev Getting CBC Token prize of participant
* @param participant Address of participant
*/
function calculateCBCPrize(address participant) public view returns(uint) {
uint payout ; //inject UNINIT LOCAL/STATE VAR
uint totalSupply ; //inject UNINIT LOCAL/STATE VAR
if (depositBears[participant] > 0) {
payout = totalSupply.mul(depositBears[participant]).div(totalSupplyOfBears);
}
if (depositBulls[participant] > 0) {
payout = totalSupply.mul(depositBulls[participant]).div(totalSupplyOfBulls);
}
return payout;
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require (msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
/**
* @title Authorizable
* @dev Allows to authorize access to certain function calls
*
* ABI
* [{"constant":true,"inputs":[{"name":"authorizerIndex","type":"uint256"}],"name":"getAuthorizer","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_addr","type":"address"}],"name":"addAuthorized","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_addr","type":"address"}],"name":"isAuthorized","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"inputs":[],"payable":false,"type":"constructor"}]
*/
contract Authorizable {
address[] authorizers;
mapping(address => uint) authorizerIndex;
/**
* @dev Throws if called by any account tat is not authorized.
*/
modifier onlyAuthorized {
require(isAuthorized(msg.sender));
_;
}
/**
* @dev Contructor that authorizes the msg.sender.
*/
constructor() public {
authorizers.length = 2;
authorizers[1] = msg.sender;
authorizerIndex[msg.sender] = 1;
}
/**
* @dev Function to get a specific authorizer
* @param authorizerIndex index of the authorizer to be retrieved.
* @return The address of the authorizer.
*/
function getAuthorizer(uint authorizerIndex) external view returns(address) {
return address(authorizers[authorizerIndex + 1]);
}
/**
* @dev Function to check if an address is authorized
* @param _addr the address to check if it is authorized.
* @return boolean flag if address is authorized.
*/
function isAuthorized(address _addr) public view returns(bool) {
return authorizerIndex[_addr] > 0;
}
/**
* @dev Function to add a new authorizer
* @param _addr the address to add as a new authorizer.
*/
function addAuthorized(address _addr) external onlyAuthorized {
authorizerIndex[_addr] = authorizers.length;
authorizers.length++;
authorizers[authorizers.length - 1] = _addr;
}
}
/**
* @title ExchangeRate
* @dev Allows updating and retrieveing of Conversion Rates for PAY tokens
*
* ABI
* [{"constant":false,"inputs":[{"name":"_symbol","type":"string"},{"name":"_rate","type":"uint256"}],"name":"updateRate","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"data","type":"uint256[]"}],"name":"updateRates","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_symbol","type":"string"}],"name":"getRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"bytes32"}],"name":"rates","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"timestamp","type":"uint256"},{"indexed":false,"name":"symbol","type":"bytes32"},{"indexed":false,"name":"rate","type":"uint256"}],"name":"RateUpdated","type":"event"}]
*/
contract ExchangeRate is Ownable {
event RateUpdated(uint timestamp, bytes32 symbol, uint rate);
mapping(bytes32 => uint) public rates;
/**
* @dev Allows the current owner to update a single rate.
* @param _symbol The symbol to be updated.
* @param _rate the rate for the symbol.
*/
function updateRate(string memory _symbol, uint _rate) public onlyOwner {
rates[keccak256(abi.encodePacked(_symbol))] = _rate;
emit RateUpdated(now, keccak256(bytes(_symbol)), _rate);
}
/**
* @dev Allows the current owner to update multiple rates.
* @param data an array that alternates keccak256 hashes of the symbol and the corresponding rate .
*/
function updateRates(uint[] memory data) public onlyOwner {
require (data.length % 2 <= 0);
uint i ; //inject UNINIT LOCAL/STATE VAR
while (i < data.length / 2) {
bytes32 symbol ; //inject UNINIT LOCAL/STATE VAR
uint rate ; //inject UNINIT LOCAL/STATE VAR
rates[symbol] = rate;
emit RateUpdated(now, symbol, rate);
i++;
}
}
/**
* @dev Allows the anyone to read the current rate.
* @param _symbol the symbol to be retrieved.
*/
function getRate(string memory _symbol) public view returns(uint) {
return rates[keccak256(abi.encodePacked(_symbol))];
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, reverts on 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-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c ; //inject UNINIT LOCAL/STATE VAR
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c ; //inject UNINIT LOCAL/STATE VAR
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c ; //inject UNINIT LOCAL/STATE VAR
return c;
}
/**
* @dev Adds two numbers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c ; //inject UNINIT LOCAL/STATE VAR
require(c >= a);
return c;
}
/**
* @dev Divides two numbers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) view public returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
/**
* @dev Fix for the ERC20 short address attack.
*/
modifier onlyPayloadSize(uint size) {
require (size + 4 <= msg.data.length);
_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint representing the amount owned by the passed address.
*/
function balanceOf(address _owner) view public returns (uint balance) {
return balances[_owner];
}
}
/**
* @title Standard ERC20 token
*
* @dev Implemantation of the basic standart token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
uint256 _allowance ; //inject UNINIT LOCAL/STATE VAR
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
emit Transfer(_from, _to, _value);
}
/**
* @dev Aprove the passed address to spend the specified amount of tokens on beahlf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) revert();
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
}
/**
* @dev Function to check the amount of tokens than an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint specifing the amount of tokens still avaible for the spender.
*/
function allowance(address _owner, address _spender) view public returns (uint remaining) {
return allowed[_owner][_spender];
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint value);
event MintFinished();
event Burn(address indexed burner, uint256 value);
bool public mintingFinished ; //inject UNINIT LOCAL/STATE VAR
uint public totalSupply ; //inject UNINIT LOCAL/STATE VAR
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that will recieve the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
return true;
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(address _who, uint256 _value) onlyOwner public {
_burn(_who, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
/**
* @title CBCToken
* @dev The main CBC token contract
*
* ABI
* [{"constant":true,"inputs":[],"name":"mintingFinished","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"startTrading","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_amount","type":"uint256"}],"name":"mint","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"tradingStarted","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"finishMinting","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"}],"name":"allowance","outputs":[{"name":"remaining","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"type":"function"},{"anonymous":false,"inputs":[{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[],"name":"MintFinished","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"spender","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Transfer","type":"event"}]
*/
contract CBCToken is MintableToken {
string public name ; //inject UNINIT LOCAL/STATE VAR
string public symbol ; //inject UNINIT LOCAL/STATE VAR
uint public decimals ; //inject UNINIT LOCAL/STATE VAR
bool public tradingStarted ; //inject UNINIT LOCAL/STATE VAR
/**
* @dev modifier that throws if trading has not started yet
*/
modifier hasStartedTrading() {
require(tradingStarted);
_;
}
/**
* @dev Allows the owner to enable the trading. This can not be undone
*/
function startTrading() onlyOwner public {
tradingStarted = true;
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @param _to the recipient address of the tokens.
* @param _value number of tokens to be transfered.
*/
function transfer(address _to, uint _value) hasStartedTrading public {
super.transfer(_to, _value);
}
/**
* @dev Allows anyone to transfer the CBC tokens once trading has started
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint _value) hasStartedTrading public{
super.transferFrom(_from, _to, _value);
}
}
/**
* @title MainSale
* @dev The main CBC token sale contract
*
* ABI
* [{"constant":false,"inputs":[{"name":"_multisigVault","type":"address"}],"name":"setMultisigVault","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"authorizerIndex","type":"uint256"}],"name":"getAuthorizer","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"exchangeRate","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"altDeposits","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"recipient","type":"address"},{"name":"tokens","type":"uint256"}],"name":"authorizedCreateTokens","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"finishMinting","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_exchangeRate","type":"address"}],"name":"setExchangeRate","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_token","type":"address"}],"name":"retrieveTokens","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"totalAltDeposits","type":"uint256"}],"name":"setAltDeposit","outputs":[],"payable":false,"type":"function"},{"constant":!1,"inputs":[{"name":"victim","type":"address"},{"name":"amount","type":"uint256"}],"name":"burnTokens","outputs":[],"payable":!1,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"start","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"recipient","type":"address"}],"name":"createTokens","outputs":[],"payable":true,"type":"function"},{"constant":false,"inputs":[{"name":"_addr","type":"address"}],"name":"addAuthorized","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"multisigVault","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_hardcap","type":"uint256"}],"name":"setHardCap","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_start","type":"uint256"}],"name":"setStart","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_addr","type":"address"}],"name":"isAuthorized","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"payable":true,"type":"fallback"},{"anonymous":false,"inputs":[{"indexed":false,"name":"recipient","type":"address"},{"indexed":false,"name":"ether_amount","type":"uint256"},{"indexed":false,"name":"pay_amount","type":"uint256"},{"indexed":false,"name":"exchangerate","type":"uint256"}],"name":"TokenSold","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"recipient","type":"address"},{"indexed":false,"name":"pay_amount","type":"uint256"}],"name":"AuthorizedCreate","type":"event"},{"anonymous":false,"inputs":[],"name":"MainSaleClosed","type":"event"}]
*/
contract MainSale is Ownable, Authorizable {
using SafeMath for uint;
event TokenSold(address recipient, uint ether_amount, uint pay_amount, uint exchangerate);
event AuthorizedCreate(address recipient, uint pay_amount);
event AuthorizedBurn(address receiver, uint value);
event AuthorizedStartTrading();
event MainSaleClosed();
CBCToken public token ; //inject UNINIT LOCAL/STATE VAR
address payable public multisigVault;
uint hardcap ; //inject UNINIT LOCAL/STATE VAR
ExchangeRate public exchangeRate;
uint public altDeposits ; //inject UNINIT LOCAL/STATE VAR
uint public start ; //inject UNINIT LOCAL/STATE VAR
/**
* @dev modifier to allow token creation only when the sale IS ON
*/
modifier saleIsOn() {
require(now > start && now < start + 28 days);
_;
}
/**
* @dev modifier to allow token creation only when the hardcap has not been reached
*/
modifier isUnderHardCap() {
require(multisigVault.balance + altDeposits <= hardcap);
_;
}
/**
* @dev Allows anyone to create tokens by depositing ether.
* @param recipient the recipient to receive tokens.
*/
function createTokens(address recipient) public isUnderHardCap saleIsOn payable {
uint rate ; //inject UNINIT LOCAL/STATE VAR
uint tokens ; //inject UNINIT LOCAL/STATE VAR
token.mint(recipient, tokens);
require(multisigVault.send(msg.value));
emit TokenSold(recipient, msg.value, tokens, rate);
}
/**
* @dev Allows to set the toal alt deposit measured in ETH to make sure the hardcap includes other deposits
* @param totalAltDeposits total amount ETH equivalent
*/
function setAltDeposit(uint totalAltDeposits) public onlyOwner {
altDeposits = totalAltDeposits;
}
/**
* @dev Allows authorized acces to create tokens. This is used for Bitcoin and ERC20 deposits
* @param recipient the recipient to receive tokens.
* @param tokens number of tokens to be created.
*/
function authorizedCreateTokens(address recipient, uint tokens) public onlyAuthorized {
token.mint(recipient, tokens);
emit AuthorizedCreate(recipient, tokens);
}
function authorizedStartTrading() public onlyAuthorized {
token.startTrading();
emit AuthorizedStartTrading();
}
/**
* @dev Allows authorized acces to burn tokens.
* @param receiver the receiver to receive tokens.
* @param value number of tokens to be created.
*/
function authorizedBurnTokens(address receiver, uint value) public onlyAuthorized {
token.burn(receiver, value);
emit AuthorizedBurn(receiver, value);
}
/**
* @dev Allows the owner to set the hardcap.
* @param _hardcap the new hardcap
*/
function setHardCap(uint _hardcap) public onlyOwner {
hardcap = _hardcap;
}
/**
* @dev Allows the owner to set the starting time.
* @param _start the new _start
*/
function setStart(uint _start) public onlyOwner {
start = _start;
}
/**
* @dev Allows the owner to set the multisig contract.
* @param _multisigVault the multisig contract address
*/
function setMultisigVault(address payable _multisigVault) public onlyOwner {
if (_multisigVault != address(0)) {
multisigVault = _multisigVault;
}
}
/**
* @dev Allows the owner to set the exchangerate contract.
* @param _exchangeRate the exchangerate address
*/
function setExchangeRate(address _exchangeRate) public onlyOwner {
exchangeRate = ExchangeRate(_exchangeRate);
}
/**
* @dev Allows the owner to finish the minting. This will create the
* restricted tokens and then close the minting.
* Then the ownership of the PAY token contract is transfered
* to this owner.
*/
function finishMinting() public onlyOwner {
uint issuedTokenSupply ; //inject UNINIT LOCAL/STATE VAR
uint restrictedTokens ; //inject UNINIT LOCAL/STATE VAR
token.mint(multisigVault, restrictedTokens);
token.finishMinting();
token.transferOwnership(owner);
emit MainSaleClosed();
}
/**
* @dev Allows the owner to transfer ERC20 tokens to the multi sig vault
* @param _token the contract address of the ERC20 contract
*/
function retrieveTokens(address _token) public onlyOwner {
ERC20 token ; //inject UNINIT LOCAL/STATE VAR
token.transfer(multisigVault, token.balanceOf(address(this)));
}
/**
* @dev Fallback function which receives ether and created the appropriate number of tokens for the
* msg.sender.
*/
function() external payable {
createTokens(msg.sender);
}
} | inject UNINIT LOCAL/STATE VAR
| string public symbol ; | 1,070,606 | [
1,
22170,
5019,
12919,
15234,
19,
7998,
8350,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
533,
1071,
3273,
274,
202,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/3/0xB8B5B7546CaEBF645BDF2331677886E88028a635/sources/MirrorInviteToken.sol | * @notice Helper to register subdomain without having to call approve. Calls register on the registrar contract. @param label The subdomain to register @param owner The owner to set/ | function register(string calldata label, address owner) external {
_register(label, owner);
}
| 16,619,116 | [
1,
2276,
358,
1744,
16242,
2887,
7999,
358,
745,
6617,
537,
18,
23665,
1744,
603,
326,
17450,
297,
6835,
18,
225,
1433,
1021,
16242,
358,
1744,
225,
3410,
1021,
3410,
358,
444,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
225,
445,
1744,
12,
1080,
745,
892,
1433,
16,
1758,
3410,
13,
3903,
288,
203,
565,
389,
4861,
12,
1925,
16,
3410,
1769,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
/* Interface to allow Deafbeef owners to change token parameters all at once.
Owners can also give editing access to up to 3 other users.
Signature can authenticate them on the deafbeef.com DAPP, to allow these
editors to perform off-chain previews of parameter changes without gas cost.
If editors have 'allowCommit' privilege, they can also commit those previews
permanently with setParams().
*/
pragma solidity >=0.6.0 <0.8.2;
abstract contract extDeafbeef721 {
function numSeries() public pure virtual returns (uint256) ;
function mint(uint256 sid, address to) public virtual returns (uint256 _tokenId);
function setPrice(uint256 sid, uint256 p) public virtual;
function setTokenParam(uint256 tokenID, uint256 i, uint32 v) public virtual;
function ownerOf(uint256 tokenId) external virtual view returns (address owner);
}
contract Changer {
extDeafbeef721 public deafbeef;
address admin_address;
event ParamsChanged(uint256 tokenID, uint32 p0,uint32 p1,uint32 p2,uint32 p3,uint32 p4,uint32 p5,uint32 p6);
//indexes which address/tokenID pairs have access to change params
struct EditStruct {
address[3] editors;
bool[3] allowCommit; //can editors also commit? or only preview
bool editingDisabled;
}
//each tokenID can have up to 3 editor addresses
mapping(uint256 => EditStruct) editorAccess;
modifier requireOwner(uint256 tokenID) {
require(msg.sender == deafbeef.ownerOf(tokenID),"Not owner of token");
_;
}
modifier requireEditor(uint256 tokenID) {
if (editorAccess[tokenID].editingDisabled && msg.sender != deafbeef.ownerOf(tokenID)) {
revert("Editing, except by owner, is disabled");
}
require(msg.sender == deafbeef.ownerOf(tokenID) ||
msg.sender == editorAccess[tokenID].editors[0] ||
msg.sender == editorAccess[tokenID].editors[1] ||
msg.sender == editorAccess[tokenID].editors[2]
,"Not owner of token,nor token editor");
_;
}
//only with commit access
modifier requireCommiter(uint256 tokenID) {
if (editorAccess[tokenID].editingDisabled && msg.sender != deafbeef.ownerOf(tokenID)) {
revert("Editing, except by owner, is disabled");
}
require(msg.sender == deafbeef.ownerOf(tokenID) ||
(msg.sender == editorAccess[tokenID].editors[0] && editorAccess[tokenID].allowCommit[0]) ||
(msg.sender == editorAccess[tokenID].editors[1] && editorAccess[tokenID].allowCommit[1]) ||
(msg.sender == editorAccess[tokenID].editors[2] && editorAccess[tokenID].allowCommit[2])
,"Not owner of token,nor token editor");
_;
}
modifier requireAdmin() {
require(admin_address == msg.sender,"Requires admin privileges");
_;
}
constructor(address _contract_address) {
deafbeef = extDeafbeef721(_contract_address);
admin_address = msg.sender;
}
//Change the contract address this applies to. Probably never needed
function setDeafbeef(address _contract_address) public requireAdmin virtual {
deafbeef = extDeafbeef721(_contract_address);
}
//only token owner can assign roles
function setEditRole(uint256 tokenID, uint256 i, address a, bool allowCommit) public requireOwner(tokenID) virtual {
editorAccess[tokenID].editors[i] = a;
editorAccess[tokenID].allowCommit[i] = allowCommit;
}
function getEditors(uint256 tokenID) public view returns(address editor0, address editor1, address editor2, bool allowCommit0, bool allowCommit1, bool allowCommit2, bool editingDisabled) {
editingDisabled = editorAccess[tokenID].editingDisabled;
editor0 = editorAccess[tokenID].editors[0];
editor1 = editorAccess[tokenID].editors[1];
editor2 = editorAccess[tokenID].editors[2];
allowCommit0 = editorAccess[tokenID].allowCommit[0];
allowCommit1 = editorAccess[tokenID].allowCommit[1];
allowCommit2 = editorAccess[tokenID].allowCommit[2];
}
// Master switch allowing owner to temporarily disable editing, without deleting the authentication list
function toggleEditing(uint256 tokenID, bool allowEditing) public requireOwner(tokenID) virtual {
editorAccess[tokenID].editingDisabled = !allowEditing;
}
//sets many parameters at once. Must be an editor with allowCommit access
/*
function setParams(uint256 tokenID, uint[] memory i, uint32[] memory v) public requireCommiter(tokenID) virtual {
require(v.length == i.length);
for (uint j=0;j<v.length;j++) {
deafbeef.setTokenParam(tokenID,i[j],v[j]);
}
}
*/
function setParams(uint256 tokenID, uint32[] memory v) public requireCommiter(tokenID) virtual {
require(v.length==7,"Must have all parameters in order from 0-6");
for (uint j=0;j<v.length;j++) {
deafbeef.setTokenParam(tokenID,j,v[j]);
}
emit ParamsChanged(tokenID,v[0],v[1],v[2],v[3],v[4],v[5],v[6]);
}
} | sets many parameters at once. Must be an editor with allowCommit access | function setParams(uint256 tokenID, uint[] memory i, uint32[] memory v) public requireCommiter(tokenID) virtual {
require(v.length == i.length);
for (uint j=0;j<v.length;j++) {
deafbeef.setTokenParam(tokenID,i[j],v[j]);
}
}
| 13,619,781 | [
1,
4424,
4906,
1472,
622,
3647,
18,
6753,
506,
392,
4858,
598,
1699,
5580,
2006,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
225,
445,
31705,
12,
11890,
5034,
1147,
734,
16,
2254,
8526,
3778,
277,
16,
2254,
1578,
8526,
3778,
331,
13,
1071,
2583,
5580,
264,
12,
2316,
734,
13,
5024,
288,
203,
565,
2583,
12,
90,
18,
2469,
422,
277,
18,
2469,
1769,
203,
565,
364,
261,
11890,
525,
33,
20,
31,
78,
32,
90,
18,
2469,
31,
78,
27245,
288,
203,
1377,
443,
1727,
70,
1340,
74,
18,
542,
1345,
786,
12,
2316,
734,
16,
77,
63,
78,
6487,
90,
63,
78,
19226,
203,
565,
289,
203,
225,
289,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
/**
* SPDX-License-Identifier: MIT
* @authors: @ferittuncer
* @reviewers: [@shalzz*, @jaybuidl]
* @auditors: []
* @bounties: []
* @deployments: []
*/
pragma solidity ^0.8.10;
import "@kleros/dispute-resolver-interface-contract/contracts/IDisputeResolver.sol";
import "./IProveMeWrong.sol";
/*
ยท---------------------------------------|---------------------------|--------------|-----------------------------ยท
| Solc version: 0.8.10 ยท Optimizer enabled: true ยท Runs: 1000 ยท Block limit: 30000000 gas โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| Methods ยท 100 gwei/gas ยท 4218.94 usd/eth โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| Contract ยท Method ยท Min ยท Max ยท Avg ยท # calls ยท usd (avg) โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| Arbitrator ยท createDispute ยท 82579 ยท 99679 ยท 84289 ยท 20 ยท 35.56 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| Arbitrator ยท executeRuling ยท - ยท - ยท 66719 ยท 3 ยท 28.15 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| Arbitrator ยท giveRuling ยท 78640 ยท 98528 ยท 93556 ยท 4 ยท 39.47 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| ProveMeWrong ยท challenge ยท - ยท - ยท 147901 ยท 3 ยท 62.40 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| ProveMeWrong ยท fundAppeal ยท 133525 ยท 138580 ยท 135547 ยท 5 ยท 57.19 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| ProveMeWrong ยท increaseBounty ยท - ยท - ยท 28602 ยท 2 ยท 12.07 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| ProveMeWrong ยท initializeClaim ยท 31655 ยท 51060 ยท 38956 ยท 10 ยท 16.44 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| ProveMeWrong ยท initiateWithdrawal ยท - ยท - ยท 28085 ยท 4 ยท 11.85 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| ProveMeWrong ยท submitEvidence ยท - ยท - ยท 26117 ยท 2 ยท 11.02 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| ProveMeWrong ยท withdraw ยท 28403 ยท 35103 ยท 30636 ยท 3 ยท 12.93 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| Deployments ยท ยท % of limit ยท โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| Arbitrator ยท - ยท - ยท 877877 ยท 2.9 % ยท 370.37 โ
ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยทยท|ยทยทยทยทยทยทยทยทยทยทยทยทยทยท
| ProveMeWrong ยท - ยท - ยท 2322785 ยท 7.7 % ยท 979.97 โ
ยท---------------------------------------|-------------|-------------|--------------|---------------|-------------ยท
*/
/** @title Prove Me Wrong
@notice Smart contract for a type of curation, where submitted items are on hold until they are withdrawn and the amount of security deposits are determined by submitters.
@dev Claims are not addressed with their identifiers. That enables us to reuse same storage address for another claim later.
Arbitrator and the extra data is fixed. Also the metaevidence. Deploy another contract to change them.
We prevent claims to get withdrawn immediately. This is to prevent submitter to escape punishment in case someone discovers an argument to debunk the claim.
Bounty amounts are compressed with a lossy compression method to save on storage cost.
*/
contract ProveMeWrong is IProveMeWrong, IArbitrable, IEvidence {
IArbitrator public immutable ARBITRATOR;
uint256 public constant NUMBER_OF_RULING_OPTIONS = 2;
uint256 public constant NUMBER_OF_LEAST_SIGNIFICANT_BITS_TO_IGNORE = 32; // To compress bounty amount to gain space in struct. Lossy compression.
uint256 public immutable WINNER_STAKE_MULTIPLIER; // Multiplier of the arbitration cost that the winner has to pay as fee stake for a round in basis points.
uint256 public immutable LOSER_STAKE_MULTIPLIER; // Multiplier of the arbitration cost that the loser has to pay as fee stake for a round in basis points.
uint256 public constant LOSER_APPEAL_PERIOD_MULTIPLIER = 5000; // Multiplier of the appeal period for losers (any other ruling options) in basis points. The loser is given less time to fund its appeal to defend against last minute appeal funding attacks.
uint256 public constant MULTIPLIER_DENOMINATOR = 10000; // Denominator for multipliers.
struct DisputeData {
address payable challenger;
RulingOptions outcome;
bool resolved; // To remove dependency to disputeStatus function of arbitrator. This function is likely to be removed in Kleros v2.
uint80 claimStorageAddress; // 2^16 is sufficient. Just using extra available space.
Round[] rounds; // Tracks each appeal round of a dispute.
}
struct Round {
mapping(address => mapping(RulingOptions => uint256)) contributions;
mapping(RulingOptions => bool) hasPaid; // True if the fees for this particular answer has been fully paid in the form hasPaid[rulingOutcome].
mapping(RulingOptions => uint256) totalPerRuling;
uint256 totalClaimableAfterExpenses;
}
struct Claim {
address payable owner;
uint32 withdrawalPermittedAt; // Overflows in year 2106.
uint64 bountyAmount; // 32-bits compression. Decompressed size is 96 bits. Can be shrinked to uint48 with 40-bits compression in case we need space for another field.
}
bytes public ARBITRATOR_EXTRA_DATA; // Immutable.
mapping(uint80 => Claim) public claimStorage; // Key: Storage address of claim. Claims are not addressed with their identifiers, to enable reusing a storage slot.
mapping(uint256 => DisputeData) disputes; // Key: Dispute ID as in arbitrator.
constructor(
IArbitrator _arbitrator,
bytes memory _arbitratorExtraData,
string memory _metaevidenceIpfsUri,
uint256 _claimWithdrawalTimelock,
uint256 _winnerStakeMultiplier,
uint256 _loserStakeMultiplier
) IProveMeWrong(_claimWithdrawalTimelock) {
ARBITRATOR = _arbitrator;
ARBITRATOR_EXTRA_DATA = _arbitratorExtraData;
WINNER_STAKE_MULTIPLIER = _winnerStakeMultiplier;
LOSER_STAKE_MULTIPLIER = _loserStakeMultiplier;
emit MetaEvidence(0, _metaevidenceIpfsUri); // Metaevidence is constant. Deploy another contract for another metaevidence.
}
/** @notice Initializes a claim.
@param _claimID Unique identifier of a claim. Usually an IPFS content identifier.
@param _searchPointer Starting point of the search. Find a vacant storage slot before calling this function to minimize gas cost.
*/
function initializeClaim(string calldata _claimID, uint80 _searchPointer) external payable override {
Claim storage claim;
do {
claim = claimStorage[_searchPointer++];
} while (claim.bountyAmount != 0);
claim.owner = payable(msg.sender);
claim.bountyAmount = uint64(msg.value >> NUMBER_OF_LEAST_SIGNIFICANT_BITS_TO_IGNORE);
require(claim.bountyAmount > 0, "You can't initialize a claim without putting a bounty.");
uint256 claimStorageAddress = _searchPointer - 1;
emit NewClaim(_claimID, claimStorageAddress);
emit BalanceUpdate(claimStorageAddress, uint256(claim.bountyAmount) << NUMBER_OF_LEAST_SIGNIFICANT_BITS_TO_IGNORE);
}
/** @notice Lets you submit evidence as defined in evidence (ERC-1497) standard.
@param _disputeID Dispute ID as in arbitrator.
@param _evidenceURI IPFS content identifier of the evidence.
*/
function submitEvidence(uint256 _disputeID, string calldata _evidenceURI) external override {
emit Evidence(ARBITRATOR, _disputeID, msg.sender, _evidenceURI);
}
/** @notice Lets you increase a bounty of a live claim.
@param _claimStorageAddress The address of the claim in the storage.
*/
function increaseBounty(uint80 _claimStorageAddress) external payable override {
Claim storage claim = claimStorage[_claimStorageAddress];
require(msg.sender == claim.owner, "Only claimant can increase bounty of a claim."); // To prevent mistakes.
claim.bountyAmount += uint64(msg.value >> NUMBER_OF_LEAST_SIGNIFICANT_BITS_TO_IGNORE);
emit BalanceUpdate(_claimStorageAddress, uint256(claim.bountyAmount) << NUMBER_OF_LEAST_SIGNIFICANT_BITS_TO_IGNORE);
}
/** @notice Lets a claimant to start withdrawal process.
@dev withdrawalPermittedAt has some special values: 0 indicates withdrawal possible but process not started yet, max value indicates there is a challenge and during challenge it's forbidden to start withdrawal process.
@param _claimStorageAddress The address of the claim in the storage.
*/
function initiateWithdrawal(uint80 _claimStorageAddress) external override {
Claim storage claim = claimStorage[_claimStorageAddress];
require(msg.sender == claim.owner, "Only claimant can withdraw a claim.");
require(claim.withdrawalPermittedAt == 0, "Withdrawal already initiated or there is a challenge.");
claim.withdrawalPermittedAt = uint32(block.timestamp + CLAIM_WITHDRAWAL_TIMELOCK);
emit TimelockStarted(_claimStorageAddress);
}
/** @notice Executes a withdrawal. Can only be executed by claimant.
@dev withdrawalPermittedAt has some special values: 0 indicates withdrawal possible but process not started yet, max value indicates there is a challenge and during challenge it's forbidden to start withdrawal process.
@param _claimStorageAddress The address of the claim in the storage.
*/
function withdraw(uint80 _claimStorageAddress) external override {
Claim storage claim = claimStorage[_claimStorageAddress];
require(msg.sender == claim.owner, "Only claimant can withdraw a claim.");
require(claim.withdrawalPermittedAt != 0, "You need to initiate withdrawal first.");
require(claim.withdrawalPermittedAt <= block.timestamp, "You need to wait for timelock or wait until the challenge ends.");
uint256 withdrawal = uint96(claim.bountyAmount) << NUMBER_OF_LEAST_SIGNIFICANT_BITS_TO_IGNORE;
claim.bountyAmount = 0; // This is critical to reset.
claim.withdrawalPermittedAt = 0; // This too, otherwise new claim inside the same slot can withdraw instantly.
payable(msg.sender).transfer(withdrawal);
emit Withdrew(_claimStorageAddress);
}
/** @notice Challenges the claim at the given storage address. Follow events to find out which claim resides in which slot.
@dev withdrawalPermittedAt has some special values: 0 indicates withdrawal possible but process not started yet, max value indicates there is a challenge and during challenge it's forbidden to start another challenge.
@param _claimStorageAddress The address of the claim in the storage.
*/
function challenge(uint80 _claimStorageAddress) public payable override {
Claim storage claim = claimStorage[_claimStorageAddress];
require(claim.withdrawalPermittedAt != type(uint32).max, "There is an ongoing challenge.");
claim.withdrawalPermittedAt = type(uint32).max; // Mark as challenged.
require(claim.bountyAmount > 0, "Nothing to challenge."); // To prevent mistakes.
uint256 disputeID = ARBITRATOR.createDispute{value: msg.value}(NUMBER_OF_RULING_OPTIONS, ARBITRATOR_EXTRA_DATA);
disputes[disputeID].challenger = payable(msg.sender);
disputes[disputeID].rounds.push();
disputes[disputeID].claimStorageAddress = uint80(_claimStorageAddress);
// Evidence group ID is dispute ID.
emit Dispute(ARBITRATOR, disputeID, 0, disputeID);
// This event links the dispute to a claim storage address.
emit Challenge(_claimStorageAddress, msg.sender, disputeID);
}
/** @notice Lets you fund a crowdfunded appeal. In case of funding is incomplete, you will be refunded. Withdrawal will be carried out using withdrawFeesAndRewards function.
@param _disputeID The dispute ID as in the arbitrator.
@param _supportedRuling The supported ruling in this funding.
*/
function fundAppeal(uint256 _disputeID, RulingOptions _supportedRuling) external payable override returns (bool fullyFunded) {
DisputeData storage dispute = disputes[_disputeID];
RulingOptions currentRuling = RulingOptions(ARBITRATOR.currentRuling(_disputeID));
uint256 basicCost;
uint256 totalCost;
{
(uint256 appealWindowStart, uint256 appealWindowEnd) = ARBITRATOR.appealPeriod(_disputeID);
uint256 multiplier;
if (_supportedRuling == currentRuling) {
require(block.timestamp < appealWindowEnd, "Funding must be made within the appeal period.");
multiplier = WINNER_STAKE_MULTIPLIER;
} else {
require(
block.timestamp < (appealWindowStart + ((appealWindowEnd - appealWindowStart) / 2)),
"Funding must be made within the first half appeal period."
);
multiplier = LOSER_STAKE_MULTIPLIER;
}
basicCost = ARBITRATOR.appealCost(_disputeID, ARBITRATOR_EXTRA_DATA);
totalCost = basicCost + ((basicCost * (multiplier)) / MULTIPLIER_DENOMINATOR);
}
RulingOptions supportedRulingOutcome = RulingOptions(_supportedRuling);
uint256 lastRoundIndex = dispute.rounds.length - 1;
Round storage lastRound = dispute.rounds[lastRoundIndex];
require(!lastRound.hasPaid[supportedRulingOutcome], "Appeal fee has already been paid.");
uint256 contribution;
{
uint256 paidSoFar = lastRound.totalPerRuling[supportedRulingOutcome];
if (paidSoFar >= totalCost) {
contribution = 0; // This can happen if arbitration fee gets lowered in between contributions.
} else {
contribution = totalCost - paidSoFar > msg.value ? msg.value : totalCost - paidSoFar;
}
}
emit Contribution(_disputeID, lastRoundIndex, _supportedRuling, msg.sender, contribution);
lastRound.contributions[msg.sender][supportedRulingOutcome] += contribution;
lastRound.totalPerRuling[supportedRulingOutcome] += contribution;
if (lastRound.totalPerRuling[supportedRulingOutcome] >= totalCost) {
lastRound.totalClaimableAfterExpenses += lastRound.totalPerRuling[supportedRulingOutcome];
lastRound.hasPaid[supportedRulingOutcome] = true;
emit RulingFunded(_disputeID, lastRoundIndex, _supportedRuling);
}
if (lastRound.hasPaid[RulingOptions.ChallengeFailed] && lastRound.hasPaid[RulingOptions.Debunked]) {
dispute.rounds.push();
lastRound.totalClaimableAfterExpenses -= basicCost;
ARBITRATOR.appeal{value: basicCost}(_disputeID, ARBITRATOR_EXTRA_DATA);
}
// Ignoring failure condition deliberately.
if (msg.value - contribution > 0) payable(msg.sender).send(msg.value - contribution);
return lastRound.hasPaid[supportedRulingOutcome];
}
/** @notice For arbitrator to call, to execute it's ruling. In case arbitrator rules in favor of challenger, challenger wins the bounty. In any case, withdrawalPermittedAt will be reset.
@param _disputeID The dispute ID as in the arbitrator.
@param _ruling The ruling that arbitrator gave.
*/
function rule(uint256 _disputeID, uint256 _ruling) external override {
require(IArbitrator(msg.sender) == ARBITRATOR);
DisputeData storage dispute = disputes[_disputeID];
Round storage lastRound = dispute.rounds[dispute.rounds.length - 1];
// Appeal overrides arbitrator ruling. If a ruling option was not fully funded and the counter ruling option was funded, funded ruling option wins by default.
RulingOptions wonByDefault;
if (lastRound.hasPaid[RulingOptions.ChallengeFailed]) {
wonByDefault = RulingOptions.ChallengeFailed;
} else if (!lastRound.hasPaid[RulingOptions.ChallengeFailed]) {
wonByDefault = RulingOptions.Debunked;
}
RulingOptions actualRuling = wonByDefault != RulingOptions.Tied ? wonByDefault : RulingOptions(_ruling);
dispute.outcome = actualRuling;
uint80 claimStorageAddress = dispute.claimStorageAddress;
Claim storage claim = claimStorage[claimStorageAddress];
if (actualRuling == RulingOptions.Debunked) {
uint256 bounty = uint96(claim.bountyAmount) << NUMBER_OF_LEAST_SIGNIFICANT_BITS_TO_IGNORE;
claim.bountyAmount = 0;
emit Debunked(claimStorageAddress);
disputes[_disputeID].challenger.send(bounty); // Ignoring failure condition deliberately.
} // In case of tie, claim stands.
claim.withdrawalPermittedAt = 0; // Unmark as challenged.
dispute.resolved = true;
emit Ruling(IArbitrator(msg.sender), _disputeID, _ruling);
}
/** @notice Allows to withdraw any rewards or reimbursable fees after the dispute gets resolved. For all rounds at once.
This function has O(m) time complexity where m is number of rounds.
It is safe to assume m is always less than 10 as appeal cost growth order is O(2^m).
@param _disputeID ID of the dispute as in arbitrator.
@param _contributor The address whose rewards to withdraw.
@param _ruling Ruling that received contributions from contributor.
*/
function withdrawFeesAndRewardsForAllRounds(
uint256 _disputeID,
address payable _contributor,
RulingOptions _ruling
) external override {
DisputeData storage dispute = disputes[_disputeID];
uint256 noOfRounds = dispute.rounds.length;
for (uint256 roundNumber = 0; roundNumber < noOfRounds; roundNumber++) {
withdrawFeesAndRewards(_disputeID, _contributor, roundNumber, _ruling);
}
}
/** @notice Allows to withdraw any reimbursable fees or rewards after the dispute gets solved.
@param _disputeID ID of the dispute as in arbitrator.
@param _contributor The address whose rewards to withdraw.
@param _roundNumber The number of the round caller wants to withdraw from.
@param _ruling Ruling that received contribution from contributor.
@return amount The amount available to withdraw for given question, contributor, round number and ruling option.
*/
function withdrawFeesAndRewards(
uint256 _disputeID,
address payable _contributor,
uint256 _roundNumber,
RulingOptions _ruling
) public override returns (uint256 amount) {
DisputeData storage dispute = disputes[_disputeID];
require(dispute.resolved, "There is no ruling yet.");
Round storage round = dispute.rounds[_roundNumber];
amount = getWithdrawableAmount(round, _contributor, _ruling, dispute.outcome);
if (amount != 0) {
round.contributions[_contributor][RulingOptions(_ruling)] = 0;
_contributor.send(amount); // Ignoring failure condition deliberately.
emit Withdrawal(_disputeID, _roundNumber, _ruling, _contributor, amount);
}
}
/** @notice Lets you to transfer ownership of a claim. This is useful when you want to change owner account without withdrawing and resubmitting.
*/
function transferOwnership(uint80 _claimStorageAddress, address payable _newOwner) external override {
Claim storage claim = claimStorage[_claimStorageAddress];
require(msg.sender == claim.owner, "Only claimant can transfer ownership.");
claim.owner = _newOwner;
}
/** @notice Returns the total amount needs to be paid to challenge a claim.
*/
function challengeFee() external view override returns (uint256 arbitrationFee) {
arbitrationFee = ARBITRATOR.arbitrationCost(ARBITRATOR_EXTRA_DATA);
}
/** @notice Returns the total amount needs to be paid to appeal a dispute.
*/
function appealFee(uint256 _disputeID) external view override returns (uint256 arbitrationFee) {
arbitrationFee = ARBITRATOR.appealCost(_disputeID, ARBITRATOR_EXTRA_DATA);
}
/** @notice Helper function to find a vacant slot for claim. Use this function before calling initialize to minimize your gas cost.
*/
function findVacantStorageSlot(uint80 _searchPointer) external view override returns (uint256 vacantSlotIndex) {
Claim storage claim;
do {
claim = claimStorage[_searchPointer++];
} while (claim.bountyAmount != 0);
return _searchPointer - 1;
}
/** @notice Returns the sum of withdrawable amount.
This function has O(m) time complexity where m is number of rounds.
It is safe to assume m is always less than 10 as appeal cost growth order is O(m^2).
*/
function getTotalWithdrawableAmount(
uint256 _disputeID,
address payable _contributor,
RulingOptions _ruling
) external view override returns (uint256 sum) {
DisputeData storage dispute = disputes[_disputeID];
if (!dispute.resolved) return 0;
uint256 noOfRounds = dispute.rounds.length;
RulingOptions finalRuling = dispute.outcome;
for (uint256 roundNumber = 0; roundNumber < noOfRounds; roundNumber++) {
Round storage round = dispute.rounds[roundNumber];
sum += getWithdrawableAmount(round, _contributor, _ruling, finalRuling);
}
}
/** @notice Returns withdrawable amount for given parameters.
*/
function getWithdrawableAmount(
Round storage _round,
address _contributor,
RulingOptions _ruling,
RulingOptions _finalRuling
) internal view returns (uint256 amount) {
RulingOptions givenRuling = RulingOptions(_ruling);
if (!_round.hasPaid[givenRuling]) {
// Allow to reimburse if funding was unsuccessful for this ruling option.
amount = _round.contributions[_contributor][givenRuling];
} else {
// Funding was successful for this ruling option.
if (_ruling == _finalRuling) {
// This ruling option is the ultimate winner.
amount = _round.totalPerRuling[givenRuling] > 0
? (_round.contributions[_contributor][givenRuling] * _round.totalClaimableAfterExpenses) / _round.totalPerRuling[givenRuling]
: 0;
} else if (!_round.hasPaid[RulingOptions(_finalRuling)]) {
// The ultimate winner was not funded in this round. Contributions discounting the appeal fee are reimbursed proportionally.
amount =
(_round.contributions[_contributor][givenRuling] * _round.totalClaimableAfterExpenses) /
(_round.totalPerRuling[RulingOptions.ChallengeFailed] + _round.totalPerRuling[RulingOptions.Debunked]);
}
}
}
}
| Overflows in year 2106.
| uint32 withdrawalPermittedAt; | 12,964,484 | [
1,
15526,
87,
316,
3286,
576,
22135,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
2254,
1578,
598,
9446,
287,
31465,
861,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/4/0xE0a9c5066061063F34A0B23d279f1ef4e5799F56/sources/NFTYMarket.sol | * @dev Creates a new order @param nftAddress - Non fungible registry address @param assetId - ID of the published NFT @param priceInWei - Price in Wei for the supported coin @param expiresAt - Duration of the order (in hours)/ | function createOrder_(
address nftAddress,
uint256 assetId,
uint256 priceInWei,
uint256 expiresAt
)
public payable
whenNotPaused
{
_createOrder(
nftAddress,
assetId,
priceInWei,
expiresAt
);
}
| 8,619,580 | [
1,
2729,
279,
394,
1353,
225,
290,
1222,
1887,
300,
3858,
9831,
75,
1523,
4023,
1758,
225,
3310,
548,
300,
1599,
434,
326,
9487,
423,
4464,
225,
6205,
382,
3218,
77,
300,
20137,
316,
1660,
77,
364,
326,
3260,
13170,
225,
7368,
861,
300,
4822,
434,
326,
1353,
261,
267,
7507,
13176,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
1,
565,
445,
752,
2448,
67,
12,
203,
3639,
1758,
290,
1222,
1887,
16,
203,
3639,
2254,
5034,
3310,
548,
16,
203,
3639,
2254,
5034,
6205,
382,
3218,
77,
16,
203,
3639,
2254,
5034,
7368,
861,
203,
565,
262,
203,
3639,
1071,
8843,
429,
203,
3639,
1347,
1248,
28590,
203,
565,
288,
203,
3639,
389,
2640,
2448,
12,
203,
5411,
290,
1222,
1887,
16,
203,
5411,
3310,
548,
16,
203,
5411,
6205,
382,
3218,
77,
16,
203,
5411,
7368,
861,
203,
3639,
11272,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.