Contract Overview
Balance:
0 BNB
BNB Value:
$0.00
My Name Tag:
Not Available, login to update
[ Download CSV Export ]
Latest 25 internal transaction
[ Download CSV Export ]
Contract Source Code Verified (Similar Match)
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0xE557B3a46345A6F5a69010ad6768219890E11A10
Contract Name:
AlpacaCore
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at BscScan.com on 2020-12-03 */ // Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol // SPDX-License-Identifier: MIT // pragma solidity ^0.6.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * // importANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } // Dependency file: contracts/interfaces/IGeneScience.sol // pragma solidity =0.6.12; interface IGeneScience { function isAlpacaGeneScience() external pure returns (bool); /** * @dev given genes of alpaca 1 & 2, return a genetic combination * @param args[0] matron id * @param args[1] matron's matron id * @param args[2] matron's sire id * @param args[3] matron gene (genes1) * @param args[4] sire id * @param args[5] sire's matron id * @param args[6] sire's sire id * @param args[7] sire gene (gene2) * @param args[8] generation * @param args[9] target block * @return gene child gene * @return energy energy associated with the gene * @return generationFactor buffs child energy, higher the generation larger the generationFactor * energy = gene energy * generationFactor */ function mixGenes(uint256[10] memory args) external view returns ( uint256 gene, uint256 energy, uint256 generationFactor ); } // Dependency file: @openzeppelin/contracts/introspection/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); } // Dependency file: @openzeppelin/contracts/introspection/ERC165Checker.sol // pragma solidity ^0.6.2; /** * @dev Library used to query support of an interface declared via {IERC165}. * * Note that these functions return the actual result of the query: they do not * `revert` if an interface is not supported. It is up to the caller to decide * what to do in these cases. */ library ERC165Checker { // As per the EIP-165 spec, no interface should ever match 0xffffffff bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff; /* * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7 */ bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7; /** * @dev Returns true if `account` supports the {IERC165} interface, */ function supportsERC165(address account) internal view returns (bool) { // Any contract that implements ERC165 must explicitly indicate support of // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid return _supportsERC165Interface(account, _INTERFACE_ID_ERC165) && !_supportsERC165Interface(account, _INTERFACE_ID_INVALID); } /** * @dev Returns true if `account` supports the interface defined by * `interfaceId`. Support for {IERC165} itself is queried automatically. * * See {IERC165-supportsInterface}. */ function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) { // query support of both ERC165 as per the spec and support of _interfaceId return supportsERC165(account) && _supportsERC165Interface(account, interfaceId); } /** * @dev Returns true if `account` supports all the interfaces defined in * `interfaceIds`. Support for {IERC165} itself is queried automatically. * * Batch-querying can lead to gas savings by skipping repeated checks for * {IERC165} support. * * See {IERC165-supportsInterface}. */ function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) { // query support of ERC165 itself if (!supportsERC165(account)) { return false; } // query support of each interface in _interfaceIds for (uint256 i = 0; i < interfaceIds.length; i++) { if (!_supportsERC165Interface(account, interfaceIds[i])) { return false; } } // all interfaces supported return true; } /** * @notice Query if a contract implements an interface, does not check ERC165 support * @param account The address of the contract to query for support of an interface * @param interfaceId The interface identifier, as specified in ERC-165 * @return true if the contract at account indicates support of the interface with * identifier interfaceId, false otherwise * @dev Assumes that account contains a contract that supports ERC165, otherwise * the behavior of this method is undefined. This precondition can be checked * with {supportsERC165}. * Interface identification is specified in ERC-165. */ function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) { // success determines whether the staticcall succeeded and result determines // whether the contract at account indicates support of _interfaceId (bool success, bool result) = _callERC165SupportsInterface(account, interfaceId); return (success && result); } /** * @notice Calls the function with selector 0x01ffc9a7 (ERC165) and suppresses throw * @param account The address of the contract to query for support of an interface * @param interfaceId The interface identifier, as specified in ERC-165 * @return success true if the STATICCALL succeeded, false otherwise * @return result true if the STATICCALL succeeded and the contract at account * indicates support of the interface with identifier interfaceId, false otherwise */ function _callERC165SupportsInterface(address account, bytes4 interfaceId) private view returns (bool, bool) { bytes memory encodedParams = abi.encodeWithSelector(_INTERFACE_ID_ERC165, interfaceId); (bool success, bytes memory result) = account.staticcall{ gas: 30000 }(encodedParams); if (result.length < 32) return (false, false); return (success, abi.decode(result, (bool))); } } // Dependency file: @openzeppelin/contracts/utils/Address.sol // pragma solidity ^0.6.2; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [// importANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // 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); } } } } // Dependency file: contracts/interfaces/ICryptoAlpacaEnergyListener.sol // pragma solidity 0.6.12; // import "@openzeppelin/contracts/introspection/IERC165.sol"; interface ICryptoAlpacaEnergyListener is IERC165 { /** @dev Handles the Alpaca energy change callback. @param id The id of the Alpaca which the energy changed @param oldEnergy The ID of the token being transferred @param newEnergy The amount of tokens being transferred */ function onCryptoAlpacaEnergyChanged( uint256 id, uint256 oldEnergy, uint256 newEnergy ) external; } // Dependency file: @openzeppelin/contracts/math/SafeMath.sol // pragma solidity ^0.6.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // Dependency file: @openzeppelin/contracts/utils/EnumerableMap.sol // pragma solidity ^0.6.0; /** * @dev Library for managing an enumerable variant of Solidity's * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`] * type. * * Maps have the following properties: * * - Entries are added, removed, and checked for existence in constant time * (O(1)). * - Entries are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableMap for EnumerableMap.UintToAddressMap; * * // Declare a set state variable * EnumerableMap.UintToAddressMap private myMap; * } * ``` * * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are * supported. */ library EnumerableMap { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Map type with // bytes32 keys and values. // The Map implementation uses private functions, and user-facing // implementations (such as Uint256ToAddressMap) are just wrappers around // the underlying Map. // This means that we can only create new EnumerableMaps for types that fit // in bytes32. struct MapEntry { bytes32 _key; bytes32 _value; } struct Map { // Storage of map keys and values MapEntry[] _entries; // Position of the entry defined by a key in the `entries` array, plus 1 // because index 0 means a key is not in the map. mapping (bytes32 => uint256) _indexes; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) { // Equivalent to !contains(map, key) map._entries.push(MapEntry({ _key: key, _value: value })); // The entry is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value map._indexes[key] = map._entries.length; return true; } else { map._entries[keyIndex - 1]._value = value; return false; } } /** * @dev Removes a key-value pair from a map. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function _remove(Map storage map, bytes32 key) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex != 0) { // Equivalent to contains(map, key) // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one // in the array, and then remove the last entry (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = keyIndex - 1; uint256 lastIndex = map._entries.length - 1; // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. MapEntry storage lastEntry = map._entries[lastIndex]; // Move the last entry to the index where the entry to delete is map._entries[toDeleteIndex] = lastEntry; // Update the index for the moved entry map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved entry was stored map._entries.pop(); // Delete the index for the deleted slot delete map._indexes[key]; return true; } else { return false; } } /** * @dev Returns true if the key is in the map. O(1). */ function _contains(Map storage map, bytes32 key) private view returns (bool) { return map._indexes[key] != 0; } /** * @dev Returns the number of key-value pairs in the map. O(1). */ function _length(Map storage map) private view returns (uint256) { return map._entries.length; } /** * @dev Returns the key-value pair stored at position `index` in the map. O(1). * * Note that there are no guarantees on the ordering of entries inside the * array, and it may change when more entries are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) { require(map._entries.length > index, "EnumerableMap: index out of bounds"); MapEntry storage entry = map._entries[index]; return (entry._key, entry._value); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function _get(Map storage map, bytes32 key) private view returns (bytes32) { return _get(map, key, "EnumerableMap: nonexistent key"); } /** * @dev Same as {_get}, with a custom error message when `key` is not in the map. */ function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key) return map._entries[keyIndex - 1]._value; // All indexes are 1-based } // UintToAddressMap struct UintToAddressMap { Map _inner; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) { return _set(map._inner, bytes32(key), bytes32(uint256(value))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) { return _remove(map._inner, bytes32(key)); } /** * @dev Returns true if the key is in the map. O(1). */ function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) { return _contains(map._inner, bytes32(key)); } /** * @dev Returns the number of elements in the map. O(1). */ function length(UintToAddressMap storage map) internal view returns (uint256) { return _length(map._inner); } /** * @dev Returns the element 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(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) { (bytes32 key, bytes32 value) = _at(map._inner, index); return (uint256(key), address(uint256(value))); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function get(UintToAddressMap storage map, uint256 key) internal view returns (address) { return address(uint256(_get(map._inner, bytes32(key)))); } /** * @dev Same as {get}, with a custom error message when `key` is not in the map. */ function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) { return address(uint256(_get(map._inner, bytes32(key), errorMessage))); } } // Dependency file: @openzeppelin/contracts/utils/ReentrancyGuard.sol // pragma solidity ^0.6.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]. */ 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 () internal { _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; } } // Dependency file: @openzeppelin/contracts/token/ERC1155/IERC1155.sol // pragma solidity ^0.6.2; // import "@openzeppelin/contracts/introspection/IERC165.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 IERC1155 is IERC165 { /** * @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; } // Dependency file: @openzeppelin/contracts/token/ERC1155/IERC1155MetadataURI.sol // pragma solidity ^0.6.2; // import "@openzeppelin/contracts/token/ERC1155/IERC1155.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 IERC1155MetadataURI is IERC1155 { /** * @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); } // Dependency file: @openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol // pragma solidity ^0.6.0; // import "@openzeppelin/contracts/introspection/IERC165.sol"; /** * _Available since v3.1._ */ interface IERC1155Receiver is IERC165 { /** @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); } // Dependency file: @openzeppelin/contracts/GSN/Context.sol // 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; } } // Dependency file: @openzeppelin/contracts/introspection/ERC165.sol // pragma solidity ^0.6.0; // import "@openzeppelin/contracts/introspection/IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts may inherit from this and call {_registerInterface} to declare * their support of an interface. */ contract ERC165 is IERC165 { /* * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7 */ bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7; /** * @dev Mapping of interface ids to whether or not it's supported. */ mapping(bytes4 => bool) private _supportedInterfaces; constructor () internal { // Derived contracts need only register support for their own interfaces, // we register support for ERC165 itself here _registerInterface(_INTERFACE_ID_ERC165); } /** * @dev See {IERC165-supportsInterface}. * * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) public view override returns (bool) { return _supportedInterfaces[interfaceId]; } /** * @dev Registers the contract as an implementer of the interface defined by * `interfaceId`. Support of the actual ERC165 interface is automatic and * registering its interface id is not required. * * See {IERC165-supportsInterface}. * * Requirements: * * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`). */ function _registerInterface(bytes4 interfaceId) internal virtual { require(interfaceId != 0xffffffff, "ERC165: invalid interface id"); _supportedInterfaces[interfaceId] = true; } } // Dependency file: @openzeppelin/contracts/token/ERC1155/ERC1155.sol // pragma solidity ^0.6.0; // import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol"; // import "@openzeppelin/contracts/token/ERC1155/IERC1155MetadataURI.sol"; // import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol"; // import "@openzeppelin/contracts/GSN/Context.sol"; // import "@openzeppelin/contracts/introspection/ERC165.sol"; // import "@openzeppelin/contracts/math/SafeMath.sol"; // import "@openzeppelin/contracts/utils/Address.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 ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI { using SafeMath for uint256; using Address 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)) private _operatorApprovals; // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json string private _uri; /* * bytes4(keccak256('balanceOf(address,uint256)')) == 0x00fdd58e * bytes4(keccak256('balanceOfBatch(address[],uint256[])')) == 0x4e1273f4 * bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465 * bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5 * bytes4(keccak256('safeTransferFrom(address,address,uint256,uint256,bytes)')) == 0xf242432a * bytes4(keccak256('safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)')) == 0x2eb2c2d6 * * => 0x00fdd58e ^ 0x4e1273f4 ^ 0xa22cb465 ^ * 0xe985e9c5 ^ 0xf242432a ^ 0x2eb2c2d6 == 0xd9b67a26 */ bytes4 private constant _INTERFACE_ID_ERC1155 = 0xd9b67a26; /* * bytes4(keccak256('uri(uint256)')) == 0x0e89341c */ bytes4 private constant _INTERFACE_ID_ERC1155_METADATA_URI = 0x0e89341c; /** * @dev See {_setURI}. */ constructor (string memory uri) public { _setURI(uri); // register the supported interfaces to conform to ERC1155 via ERC165 _registerInterface(_INTERFACE_ID_ERC1155); // register the supported interfaces to conform to ERC1155MetadataURI via ERC165 _registerInterface(_INTERFACE_ID_ERC1155_METADATA_URI); } /** * @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) external view 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 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 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) { require(accounts[i] != address(0), "ERC1155: batch balance query for the zero address"); batchBalances[i] = _balances[ids[i]][accounts[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 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); _balances[id][from] = _balances[id][from].sub(amount, "ERC1155: insufficient balance for transfer"); _balances[id][to] = _balances[id][to].add(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]; _balances[id][from] = _balances[id][from].sub( amount, "ERC1155: insufficient balance for transfer" ); _balances[id][to] = _balances[id][to].add(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 `to` 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] = _balances[id][account].add(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].add(_balances[ids[i]][to]); } 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), ""); _balances[id][account] = _balances[id][account].sub( amount, "ERC1155: burn amount exceeds balance" ); 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++) { _balances[ids[i]][account] = _balances[ids[i]][account].sub( amounts[i], "ERC1155: burn amount exceeds balance" ); } 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 IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) { if (response != IERC1155Receiver(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 IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) { if (response != IERC1155Receiver(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; } } // Dependency file: @openzeppelin/contracts/access/Ownable.sol // pragma solidity ^0.6.0; // import "@openzeppelin/contracts/GSN/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. */ 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; } } // Dependency file: contracts/interfaces/IAlpaSupplier.sol // pragma solidity 0.6.12; interface IAlpaSupplier { /** * @dev mint and distribute ALPA to caller * NOTE: caller must be approved consumer */ function distribute(uint256 _since) external returns (uint256); /** * @dev mint and distribute exact amount of ALPA to caller * NOTE: caller must be approved consumer */ function distributeExact(uint256 _amount) external returns (uint256); /** * @dev returns number of ALPA _consumer is expected to recieved at current block * NOTE: caller must be approved consumer */ function preview(address _consumer, uint256 _since) external view returns (uint256); /** * @dev burn alpa * NOTE: caller must be approved consumer */ function burn(address _account, uint256 _amount) external; } // Dependency file: contracts/CryptoAlpaca/AlpacaBase.sol // pragma solidity =0.6.12; // import "@openzeppelin/contracts/math/SafeMath.sol"; // import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; // import "@openzeppelin/contracts/utils/EnumerableMap.sol"; // import "@openzeppelin/contracts/access/Ownable.sol"; // import "contracts/interfaces/IGeneScience.sol"; // import "contracts/interfaces/IAlpaSupplier.sol"; contract AlpacaBase is Ownable { using SafeMath for uint256; /* ========== ENUM ========== */ /** * @dev Alpaca can be in one of the two state: * * EGG - When two alpaca breed with each other, alpaca EGG is created. * `gene` and `energy` are both 0 and will be assigned when egg is cracked * * GROWN - When egg is cracked and alpaca is born! `gene` and `energy` are determined * in this state. */ enum AlpacaGrowthState {EGG, GROWN} /* ========== PUBLIC STATE VARIABLES ========== */ /** * @dev payment required to use cracked if it's done automatically * assigning to 0 indicate cracking action is not automatic */ uint256 public autoCrackingFee = 0; /** * @dev Base breeding ALPA fee */ uint256 public baseHatchingFee = 10e18; // 10 ALPA /** * @dev ALPA ERC20 contract address */ IERC20 public alpa; /** * @dev 10% of the breeding ALPA fee goes to `devAddress` */ address public devAddress; /** * @dev 10% of the breeding ALPA fee goes to `devAddress` */ IAlpaSupplier public alpaSupplier; /** * @dev number of percentage breeding ALPA fund goes to devAddress * dev percentage = devBreedingPercentage / 100 * staking percentage = (100 - devBreedingPercentage) / 100 */ uint256 public devBreedingPercentage = 10; /** * @dev An approximation of currently how many seconds are in between blocks. */ uint256 public secondsPerBlock = 3; /** * @dev amount of time a new born alpaca needs to wait before participating in breeding activity. */ uint256 public newBornCoolDown = uint256(3 days); /** * @dev amount of time an egg needs to wait to be cracked */ uint256 public hatchingDuration = uint256(5 minutes); /** * @dev when two alpaca just bred, the breeding multiplier will doubled to control * alpaca's population. This is the amount of time each parent must wait for the * breeding multiplier to reset back to 1 */ uint256 public hatchingMultiplierCoolDown = uint256(7 days); /** * @dev hard cap on the maximum hatching cost multiplier it can reach to */ uint16 public maxHatchCostMultiplier = 8; /** * @dev Gen0 generation factor */ uint64 public constant GEN0_GENERATION_FACTOR = 10; /** * @dev hatching fee increase with higher alpa generation */ uint256 public generationHatchingFeeMultiplier = 2; /** * @dev gene science contract address for genetic combination algorithm. */ IGeneScience public geneScience; /* ========== INTERNAL STATE VARIABLES ========== */ /** * @dev An array containing the Alpaca struct for all Alpacas in existence. The ID * of each alpaca is the index into this array. */ Alpaca[] internal alpacas; /** * @dev mapping from AlpacaIDs to an address where alpaca owner approved address to use * this alpca for breeding. addrss can breed with this cat multiple times without limit. * This will be resetted everytime someone transfered the alpaca. */ EnumerableMap.UintToAddressMap internal alpacaAllowedToAddress; /* ========== ALPACA STRUCT ========== */ /** * @dev Everything about your alpaca is stored in here. Each alpaca's appearance * is determined by the gene. The energy associated with each alpaca is also * related to the gene */ struct Alpaca { // Theaalpaca genetic code. uint256 gene; // the alpaca energy level uint32 energy; // The timestamp from the block when this alpaca came into existence. uint64 birthTime; // The minimum timestamp alpaca needs to wait to avoid hatching multiplier uint64 hatchCostMultiplierEndBlock; // hatching cost multiplier uint16 hatchingCostMultiplier; // The ID of the parents of this alpaca, set to 0 for gen0 alpaca. uint32 matronId; uint32 sireId; // The "generation number" of this alpaca. The generation number of an alpacas // is the smaller of the two generation numbers of their parents, plus one. uint16 generation; // The minimum timestamp new born alpaca needs to wait to hatch egg. uint64 cooldownEndBlock; // The generation factor buffs alpaca energy level uint64 generationFactor; // defines current alpaca state AlpacaGrowthState state; } /* ========== VIEW ========== */ function getTotalAlpaca() external view returns (uint256) { return alpacas.length; } function _getBaseHatchingCost(uint256 _generation) internal view returns (uint256) { return baseHatchingFee.add( _generation.mul(generationHatchingFeeMultiplier).mul(1e18) ); } /* ========== OWNER MUTATIVE FUNCTION ========== */ /** * @param _hatchingDuration hatching duration */ function setHatchingDuration(uint256 _hatchingDuration) external onlyOwner { hatchingDuration = _hatchingDuration; } /** * @param _devAddress dev address */ function setDevAddress(address _devAddress) external onlyDev { devAddress = _devAddress; } /** * @param _maxHatchCostMultiplier max hatch cost multiplier */ function setMaxHatchCostMultiplier(uint16 _maxHatchCostMultiplier) external onlyOwner { maxHatchCostMultiplier = _maxHatchCostMultiplier; } /** * @param _devBreedingPercentage base generation factor */ function setDevBreedingPercentage(uint256 _devBreedingPercentage) external onlyOwner { require(devBreedingPercentage <= 100); devBreedingPercentage = _devBreedingPercentage; } /** * @param _generationHatchingFeeMultiplier multiplier */ function setGenerationHatchingFeeMultiplier( uint256 _generationHatchingFeeMultiplier ) external onlyOwner { generationHatchingFeeMultiplier = _generationHatchingFeeMultiplier; } /** * @param _baseHatchingFee base birthing */ function setBaseHatchingFee(uint256 _baseHatchingFee) external onlyOwner { baseHatchingFee = _baseHatchingFee; } /** * @param _newBornCoolDown new born cool down */ function setNewBornCoolDown(uint256 _newBornCoolDown) external onlyOwner { newBornCoolDown = _newBornCoolDown; } /** * @param _hatchingMultiplierCoolDown base birthing */ function setHatchingMultiplierCoolDown(uint256 _hatchingMultiplierCoolDown) external onlyOwner { hatchingMultiplierCoolDown = _hatchingMultiplierCoolDown; } /** * @dev update how many seconds per blocks are currently observed. * @param _secs number of seconds */ function setSecondsPerBlock(uint256 _secs) external onlyOwner { secondsPerBlock = _secs; } /** * @dev only owner can update autoCrackingFee */ function setAutoCrackingFee(uint256 _autoCrackingFee) external onlyOwner { autoCrackingFee = _autoCrackingFee; } /** * @dev owner can upgrading gene science */ function setGeneScience(IGeneScience _geneScience) external onlyOwner { require(_geneScience.isAlpacaGeneScience()); // Set the new contract address geneScience = _geneScience; } /** * @dev owner can update ALPA erc20 token location */ function setAlpaContract(IERC20 _alpa) external onlyOwner { alpa = _alpa; } /* ========== MODIFIER ========== */ /** * @dev Throws if called by any account other than the dev. */ modifier onlyDev() { require(devAddress == _msgSender()); _; } } // Dependency file: contracts/CryptoAlpaca/AlpacaToken.sol // pragma solidity =0.6.12; // import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol"; // import "contracts/CryptoAlpaca/AlpacaBase.sol"; contract AlpacaToken is AlpacaBase, ERC1155("") { /* ========== EVENTS ========== */ /** * @dev Emitted when single `alpacaId` alpaca with `gene` and `energy` is born */ event BornSingle(uint256 indexed alpacaId, uint256 gene, uint256 energy); /** * @dev Equivalent to multiple {BornSingle} events */ event BornBatch(uint256[] alpacaIds, uint256[] genes, uint256[] energy); /* ========== VIEWS ========== */ /** * @dev Check if `_alpacaId` is owned by `_account` */ function isOwnerOf(address _account, uint256 _alpacaId) public view returns (bool) { return balanceOf(_account, _alpacaId) == 1; } /* ========== OWNER MUTATIVE FUNCTION ========== */ /** * @dev Allow contract owner to update URI to look up all alpaca metadata */ function setURI(string memory _newuri) external onlyOwner { _setURI(_newuri); } /** * @dev Allow contract owner to create alpaca with `_gene`, * `_energy` and transfer to `owner` */ function createAlpaca( uint256 _gene, uint256 _energy, uint16 _generation, address _owner ) external onlyOwner { address alpacaOwner = _owner; if (alpacaOwner == address(0)) { alpacaOwner = owner(); } _createAlpaca(_gene, _energy, _generation, alpacaOwner); } /** * @dev Equivalent to multiple {createAlpaca} function */ function createAlpacaBatch( uint256[] memory _genes, uint256[] memory _energies, uint16 _generation, address _owner ) external onlyOwner { address alpacaOwner = _owner; if (alpacaOwner == address(0)) { alpacaOwner = owner(); } _createAlpacaBatch(_genes, _energies, _generation, _owner); } /* ========== INTERNAL ALPA GENERATION ========== */ /** * @dev Create an alpaca egg. Egg's `gene` and `energy` will assigned to 0 * initially and won't be determined until egg is cracked. */ function _createEgg( uint256 _matronId, uint256 _sireId, uint256 _generation, uint256 _cooldownEndBlock, address _owner ) internal returns (uint256) { require(_matronId == uint256(uint32(_matronId))); require(_sireId == uint256(uint32(_sireId))); require(_generation == uint256(uint16(_generation))); Alpaca memory _alpaca = Alpaca({ gene: 0, energy: 0, birthTime: uint64(now), hatchCostMultiplierEndBlock: 0, hatchingCostMultiplier: 1, matronId: uint32(_matronId), sireId: uint32(_sireId), cooldownEndBlock: uint64(_cooldownEndBlock), generation: uint16(_generation), generationFactor: 0, state: AlpacaGrowthState.EGG }); alpacas.push(_alpaca); uint256 eggId = alpacas.length - 1; _mint(_owner, eggId, 1, ""); return eggId; } /** * @dev Internal alpaca creation function */ function _createAlpaca( uint256 _gene, uint256 _energy, uint16 _generation, address _owner ) internal returns (uint256) { Alpaca memory _alpaca = Alpaca({ gene: _gene, energy: uint32(_energy), birthTime: uint64(now), hatchCostMultiplierEndBlock: 0, hatchingCostMultiplier: 1, matronId: 0, sireId: 0, cooldownEndBlock: 0, generation: _generation, generationFactor: GEN0_GENERATION_FACTOR, state: AlpacaGrowthState.GROWN }); alpacas.push(_alpaca); uint256 newAlpacaID = alpacas.length - 1; _mint(_owner, newAlpacaID, 1, ""); // emit the born event emit BornSingle(newAlpacaID, _gene, _energy); return newAlpacaID; } /** * @dev Internal alpaca batch creation function */ function _createAlpacaBatch( uint256[] memory _genes, uint256[] memory _energies, uint16 _generation, address _owner ) internal returns (uint256[] memory) { require(_genes.length > 0); require(_genes.length == _energies.length); uint256 alpacaIdStart = alpacas.length; uint256[] memory ids = new uint256[](_genes.length); uint256[] memory amount = new uint256[](_genes.length); for (uint256 i = 0; i < _genes.length; i++) { Alpaca memory _alpaca = Alpaca({ gene: _genes[i], energy: uint32(_energies[i]), birthTime: uint64(now), hatchCostMultiplierEndBlock: 0, hatchingCostMultiplier: 1, matronId: 0, sireId: 0, cooldownEndBlock: 0, generation: _generation, generationFactor: GEN0_GENERATION_FACTOR, state: AlpacaGrowthState.GROWN }); alpacas.push(_alpaca); ids[i] = alpacaIdStart + i; amount[i] = 1; } _mintBatch(_owner, ids, amount, ""); emit BornBatch(ids, _genes, _energies); return ids; } } // Dependency file: contracts/interfaces/ICryptoAlpaca.sol // pragma solidity =0.6.12; // import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol"; interface ICryptoAlpaca is IERC1155 { function getAlpaca(uint256 _id) external view returns ( uint256 id, bool isReady, uint256 cooldownEndBlock, uint256 birthTime, uint256 matronId, uint256 sireId, uint256 hatchingCost, uint256 hatchingCostMultiplier, uint256 hatchCostMultiplierEndBlock, uint256 generation, uint256 gene, uint256 energy, uint256 state ); function hasPermissionToBreedAsSire(address _addr, uint256 _id) external view returns (bool); function grantPermissionToBreed(address _addr, uint256 _sireId) external; function clearPermissionToBreed(uint256 _alpacaId) external; function hatch(uint256 _matronId, uint256 _sireId) external payable returns (uint256); function crack(uint256 _id) external; } // Dependency file: contracts/CryptoAlpaca/AlpacaBreed.sol // pragma solidity =0.6.12; // import "@openzeppelin/contracts/math/SafeMath.sol"; // import "@openzeppelin/contracts/utils/EnumerableMap.sol"; // import "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; // import "contracts/CryptoAlpaca/AlpacaToken.sol"; // import "contracts/interfaces/ICryptoAlpaca.sol"; contract AlpacaBreed is AlpacaToken, ICryptoAlpaca, ReentrancyGuard { using SafeMath for uint256; using EnumerableMap for EnumerableMap.UintToAddressMap; /* ========== EVENTS ========== */ // The Hatched event is fired when two alpaca successfully hached an egg. event Hatched( uint256 indexed eggId, uint256 matronId, uint256 sireId, uint256 cooldownEndBlock ); // The GrantedToBreed event is fired whne an alpaca's owner granted // addr account to use alpacaId as sire to breed. event GrantedToBreed(uint256 indexed alpacaId, address addr); // The RevokedPermissionToBreed event is fired whne an alpaca's owner cleared // addr account to use alpacaId as sire to breed. event ClearPermissionToBreed(uint256 indexed alpacaId); /* ========== VIEWS ========== */ /** * Returns all the relevant information about a specific alpaca. * @param _id The ID of the alpaca of interest. */ function getAlpaca(uint256 _id) external override view returns ( uint256 id, bool isReady, uint256 cooldownEndBlock, uint256 birthTime, uint256 matronId, uint256 sireId, uint256 hatchingCost, uint256 hatchingCostMultiplier, uint256 hatchCostMultiplierEndBlock, uint256 generation, uint256 gene, uint256 energy, uint256 state ) { Alpaca storage alpaca = alpacas[_id]; id = _id; isReady = (alpaca.cooldownEndBlock <= block.number); cooldownEndBlock = alpaca.cooldownEndBlock; birthTime = alpaca.birthTime; matronId = alpaca.matronId; sireId = alpaca.sireId; hatchingCost = _getBaseHatchingCost(alpaca.generation); hatchingCostMultiplier = alpaca.hatchingCostMultiplier; if (alpaca.hatchCostMultiplierEndBlock <= block.number) { hatchingCostMultiplier = 1; } hatchCostMultiplierEndBlock = alpaca.hatchCostMultiplierEndBlock; generation = alpaca.generation; gene = alpaca.gene; energy = alpaca.energy; state = uint256(alpaca.state); } /** * @dev Calculating hatching ALPA cost */ function hatchingALPACost(uint256 _matronId, uint256 _sireId) external view returns (uint256) { return _hatchingALPACost(_matronId, _sireId, false); } /** * @dev Checks to see if a given egg passed cooldownEndBlock and ready to crack * @param _id alpaca egg ID */ function isReadyToCrack(uint256 _id) external view returns (bool) { Alpaca storage alpaca = alpacas[_id]; return (alpaca.state == AlpacaGrowthState.EGG) && (alpaca.cooldownEndBlock <= uint64(block.number)); } /* ========== EXTERNAL MUTATIVE FUNCTIONS ========== */ /** * Grants permission to another account to sire with one of your alpacas. * @param _addr The address that will be able to use sire for breeding. * @param _sireId a alpaca _addr will be able to use for breeding as sire. */ function grantPermissionToBreed(address _addr, uint256 _sireId) external override { require(isOwnerOf(msg.sender, _sireId)); alpacaAllowedToAddress.set(_sireId, _addr); emit GrantedToBreed(_sireId, _addr); } /** * check if `_addr` has permission to user alpaca `_id` to breed with as sire. */ function hasPermissionToBreedAsSire(address _addr, uint256 _id) external override view returns (bool) { if (isOwnerOf(_addr, _id)) { return true; } return alpacaAllowedToAddress.contains(_id) && alpacaAllowedToAddress.get(_id) == _addr; } /** * Clear the permission on alpaca for another user to use to breed. * @param _alpacaId a alpaca to clear permission . */ function clearPermissionToBreed(uint256 _alpacaId) external override { require(isOwnerOf(msg.sender, _alpacaId)); alpacaAllowedToAddress.remove(_alpacaId); emit ClearPermissionToBreed(_alpacaId); } /** * @dev Hatch an baby alpaca egg with two alpaca you own (_matronId and _sireId). * Requires a pre-payment of the fee given out to the first caller of crack() * @param _matronId The ID of the Alpaca acting as matron * @param _sireId The ID of the Alpaca acting as sire * @return The hatched alpaca egg ID */ function hatch(uint256 _matronId, uint256 _sireId) external override payable nonReentrant returns (uint256) { address msgSender = msg.sender; // Checks for payment. require(msg.value >= autoCrackingFee, "AC: autoCrackingFee not sent"); // Checks for ALPA payment require( alpa.allowance(msgSender, address(this)) >= _hatchingALPACost(_matronId, _sireId, true), "AC: insufficient ALPA" ); // Checks if matron and sire are valid mating pair require( _ownerPermittedToBreed(msgSender, _matronId, _sireId), "AC: invalid permission" ); // Grab a reference to the potential matron Alpaca storage matron = alpacas[_matronId]; // Make sure matron isn't pregnant, or in the middle of a siring cooldown require(_isReadyToHatch(matron), "AC: matron not ready"); // Grab a reference to the potential sire Alpaca storage sire = alpacas[_sireId]; // Make sure sire isn't pregnant, or in the middle of a siring cooldown require(_isReadyToHatch(sire), "AC: Sire not ready"); // Test that matron and sire are a valid mating pair. require( _isValidMatingPair(matron, _matronId, sire, _sireId), "AC: invalid mating pair" ); // All checks passed, Alpaca gets pregnant! return _hatchEgg(_matronId, _sireId); } /** * @dev egg is ready to crack and give life to baby alpaca! * @param _id A Alpaca egg that's ready to crack. */ function crack(uint256 _id) external override nonReentrant { // Grab a reference to the egg in storage. Alpaca storage egg = alpacas[_id]; // Check that the egg is a valid alpaca. require(egg.birthTime != 0, "AC: invalid egg"); require(egg.state == AlpacaGrowthState.EGG, "AC: invalid egg"); // Check that the matron is pregnant, and that its time has come! require(_isReadyToCrack(egg), "AC: not ready"); // Grab a reference to the sire in storage. Alpaca storage matron = alpacas[egg.matronId]; Alpaca storage sire = alpacas[egg.sireId]; uint256[10] memory args = [ egg.matronId, matron.matronId, matron.sireId, matron.gene, egg.sireId, sire.matronId, sire.sireId, sire.gene, egg.generation, uint256(egg.cooldownEndBlock).sub(1) ]; // Call the sooper-sekret gene mixing operation. ( uint256 childGene, uint256 childEnergy, uint256 generationFactor ) = geneScience.mixGenes(args); egg.gene = childGene; egg.energy = uint32(childEnergy); egg.state = AlpacaGrowthState.GROWN; egg.cooldownEndBlock = uint64( (newBornCoolDown.div(secondsPerBlock)).add(block.number) ); egg.generationFactor = uint64(generationFactor); // Send the balance fee to the person who made birth happen. if (autoCrackingFee > 0) { msg.sender.transfer(autoCrackingFee); } // emit the born event emit BornSingle(_id, childGene, childEnergy); } /* ========== PRIVATE FUNCTION ========== */ /** * @dev Recalculate the hatchingCostMultiplier for alpaca after breed. * If hatchCostMultiplierEndBlock is less than current block number * reset hatchingCostMultiplier back to 2, otherwize multiply hatchingCostMultiplier by 2. Also update * hatchCostMultiplierEndBlock. */ function _refreshHatchingMultiplier(Alpaca storage _alpaca) private { if (_alpaca.hatchCostMultiplierEndBlock < block.number) { _alpaca.hatchingCostMultiplier = 2; } else { uint16 newMultiplier = _alpaca.hatchingCostMultiplier * 2; if (newMultiplier > maxHatchCostMultiplier) { newMultiplier = maxHatchCostMultiplier; } _alpaca.hatchingCostMultiplier = newMultiplier; } _alpaca.hatchCostMultiplierEndBlock = uint64( (hatchingMultiplierCoolDown.div(secondsPerBlock)).add(block.number) ); } function _ownerPermittedToBreed( address _sender, uint256 _matronId, uint256 _sireId ) private view returns (bool) { // owner must own matron, othersize not permitted bool ownMatron = isOwnerOf(_sender, _matronId); bool hasPermissionMatron = false; if (!ownMatron) { hasPermissionMatron = alpacaAllowedToAddress.contains(_matronId) && alpacaAllowedToAddress.get(_matronId) == _sender; } bool ownSire = isOwnerOf(_sender, _sireId); bool hasPermissionSire = false; if (!ownSire) { hasPermissionSire = alpacaAllowedToAddress.contains(_sireId) && alpacaAllowedToAddress.get(_sireId) == _sender; } return (ownMatron || hasPermissionMatron) && (ownSire || hasPermissionSire); } /** * @dev Checks that a given alpaca is able to breed. Requires that the * current cooldown is finished (for sires) and also checks that there is * no pending pregnancy. */ function _isReadyToHatch(Alpaca storage _alpaca) private view returns (bool) { return (_alpaca.state == AlpacaGrowthState.GROWN) && (_alpaca.cooldownEndBlock < uint64(block.number)); } /** * @dev Checks to see if a given alpaca is pregnant and (if so) if the gestation * period has passed. */ function _isReadyToCrack(Alpaca storage _egg) private view returns (bool) { return (_egg.state == AlpacaGrowthState.EGG) && (_egg.cooldownEndBlock < uint64(block.number)); } /** * @dev Calculating breeding ALPA cost for internal usage. */ function _hatchingALPACost( uint256 _matronId, uint256 _sireId, bool _strict ) private view returns (uint256) { uint256 blockNum = block.number; if (!_strict) { blockNum = blockNum + 1; } Alpaca storage sire = alpacas[_sireId]; uint256 sireHatchingBase = _getBaseHatchingCost(sire.generation); uint256 sireMultiplier = sire.hatchingCostMultiplier; if (sire.hatchCostMultiplierEndBlock < blockNum) { sireMultiplier = 1; } Alpaca storage matron = alpacas[_matronId]; uint256 matronHatchingBase = _getBaseHatchingCost(matron.generation); uint256 matronMultiplier = matron.hatchingCostMultiplier; if (matron.hatchCostMultiplierEndBlock < blockNum) { matronMultiplier = 1; } return (sireHatchingBase.mul(sireMultiplier)).add( matronHatchingBase.mul(matronMultiplier) ); } /** * @dev Internal utility function to initiate hatching egg, assumes that all breeding * requirements have been checked. */ function _hatchEgg(uint256 _matronId, uint256 _sireId) private returns (uint256) { // Transfer birthing ALPA fee to this contract uint256 alpaCost = _hatchingALPACost(_matronId, _sireId, true); uint256 devAmount = alpaCost.mul(devBreedingPercentage).div(100); uint256 burnAmount = alpaCost.sub(devAmount); // devBreedingPercentage goes to dev address assert(alpa.transferFrom(msg.sender, devAddress, devAmount)); // burn the rest alpaSupplier.burn(msg.sender, burnAmount); // Grab a reference to the Alpacas from storage. Alpaca storage sire = alpacas[_sireId]; Alpaca storage matron = alpacas[_matronId]; // refresh hatching multiplier for both parents. _refreshHatchingMultiplier(sire); _refreshHatchingMultiplier(matron); // Determine the lower generation number of the two parents uint256 parentGen = matron.generation; if (sire.generation < matron.generation) { parentGen = sire.generation; } // child generation will be 1 larger than min of the two parents generation; uint256 childGen = parentGen.add(1); // Determine when the egg will be cracked uint256 cooldownEndBlock = (hatchingDuration.div(secondsPerBlock)).add( block.number ); uint256 eggID = _createEgg( _matronId, _sireId, childGen, cooldownEndBlock, msg.sender ); // Emit the hatched event. emit Hatched(eggID, _matronId, _sireId, cooldownEndBlock); return eggID; } /** * @dev Internal check to see if a given sire and matron are a valid mating pair. * @param _matron A reference to the Alpaca struct of the potential matron. * @param _matronId The matron's ID. * @param _sire A reference to the Alpaca struct of the potential sire. * @param _sireId The sire's ID */ function _isValidMatingPair( Alpaca storage _matron, uint256 _matronId, Alpaca storage _sire, uint256 _sireId ) private view returns (bool) { // A Aapaca can't breed with itself if (_matronId == _sireId) { return false; } // Alpaca can't breed with their parents. if (_matron.matronId == _sireId || _matron.sireId == _sireId) { return false; } if (_sire.matronId == _matronId || _sire.sireId == _matronId) { return false; } return true; } /** * @dev openzeppelin ERC1155 Hook that is called before any token transfer * Clear any alpacaAllowedToAddress associated to the alpaca * that's been transfered */ function _beforeTokenTransfer( address, address, address, uint256[] memory ids, uint256[] memory, bytes memory ) internal virtual override { for (uint256 i = 0; i < ids.length; i++) { if (alpacaAllowedToAddress.contains(ids[i])) { alpacaAllowedToAddress.remove(ids[i]); } } } } // Dependency file: contracts/CryptoAlpaca/AlpacaOperator.sol // pragma solidity =0.6.12; // import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; // import "@openzeppelin/contracts/introspection/IERC165.sol"; // import "@openzeppelin/contracts/introspection/ERC165Checker.sol"; // import "@openzeppelin/contracts/utils/Address.sol"; // import "contracts/interfaces/IGeneScience.sol"; // import "contracts/interfaces/ICryptoAlpacaEnergyListener.sol"; // import "contracts/CryptoAlpaca/AlpacaBreed.sol"; contract AlpacaOperator is AlpacaBreed { using Address for address; using ERC165Checker for address; address public operator; /* * bytes4(keccak256('onCryptoAlpacaEnergyChanged(uint256,uint256,uint256)')) == 0x5a864e1c */ bytes4 private constant _INTERFACE_ID_CRYPTO_ALPACA_ENERGY_LISTENER = 0x5a864e1c; /* ========== EVENTS ========== */ /** * @dev Event for when alpaca's energy changed from `fromEnergy` */ event EnergyChanged( uint256 indexed id, uint256 oldEnergy, uint256 newEnergy ); /** * @dev Event for when alpaca's HatchingCostMultiplier changed */ event HatchingCostMultiplierChanged( uint256 indexed id, uint256 oldHatchingCostMultiplier, uint256 newHatchingCostMultiplier ); /** * @dev Event for when alpaca's HatchCostMultiplierEndBlock changed */ event HatchCostMultiplierEndBlockChanged( uint256 indexed id, uint256 oldHatchCostMultiplierEndBlock, uint256 newHatchCostMultiplierEndBlock ); /** * @dev Event for when alpaca's CooldownEndBlock changed */ event CooldownEndBlockChanged( uint256 indexed id, uint256 oldCooldownEndBlock, uint256 newCooldownEndBlock ); /** * @dev Event for when alpaca's gene changed */ event GeneChanged(uint256 indexed id, uint256 oldGene, uint256 newGene); /* ========== OPERATOR ONLY FUNCTION ========== */ function updateAlpacaEnergy( address _owner, uint256 _id, uint32 _newEnergy ) external onlyOperator nonReentrant { require(_newEnergy > 0); require(isOwnerOf(_owner, _id)); Alpaca storage thisAlpaca = alpacas[_id]; uint32 oldEnergy = thisAlpaca.energy; thisAlpaca.energy = _newEnergy; emit EnergyChanged(_id, oldEnergy, _newEnergy); _doSafeEnergyChangedAcceptanceCheck(_owner, _id, oldEnergy, _newEnergy); } function updateAlpacaHatchingCostMultiplier( uint256 _id, uint16 _hatchingCostMultiplier ) external onlyOperator { Alpaca storage thisAlpaca = alpacas[_id]; uint16 oldHatchingCostMultiplier = thisAlpaca.hatchingCostMultiplier; thisAlpaca.hatchingCostMultiplier = _hatchingCostMultiplier; emit HatchingCostMultiplierChanged( _id, oldHatchingCostMultiplier, _hatchingCostMultiplier ); } function updateAlpacaHatchCostMultiplierEndBlock( uint256 _id, uint64 _hatchCostMultiplierEndBlock ) external onlyOperator { Alpaca storage thisAlpaca = alpacas[_id]; uint64 oldHatchCostMultiplierEndBlock = thisAlpaca .hatchCostMultiplierEndBlock; thisAlpaca.hatchCostMultiplierEndBlock = _hatchCostMultiplierEndBlock; emit HatchingCostMultiplierChanged( _id, oldHatchCostMultiplierEndBlock, _hatchCostMultiplierEndBlock ); } function updateAlpacaCooldownEndBlock(uint256 _id, uint64 _cooldownEndBlock) external onlyOperator { Alpaca storage thisAlpaca = alpacas[_id]; uint64 oldCooldownEndBlock = thisAlpaca.cooldownEndBlock; thisAlpaca.cooldownEndBlock = _cooldownEndBlock; emit CooldownEndBlockChanged( _id, oldCooldownEndBlock, _cooldownEndBlock ); } function updateAlpacaGene(uint256 _id, uint256 _gene) external onlyOperator { Alpaca storage thisAlpaca = alpacas[_id]; uint256 oldGene = thisAlpaca.gene; thisAlpaca.gene = _gene; emit GeneChanged(_id, oldGene, _gene); } /** * @dev Transfers operator role to different address * Can only be called by the current operator. */ function transferOperator(address _newOperator) external onlyOperator { require(_newOperator != address(0)); operator = _newOperator; } /* ========== MODIFIERS ========== */ /** * @dev Throws if called by any account other than operator. */ modifier onlyOperator() { require(operator == _msgSender()); _; } /* =========== PRIVATE ========= */ function _doSafeEnergyChangedAcceptanceCheck( address _to, uint256 _id, uint256 _oldEnergy, uint256 _newEnergy ) private { if (_to.isContract() && _to.supportsERC165()) { if ( IERC165(_to).supportsInterface( _INTERFACE_ID_CRYPTO_ALPACA_ENERGY_LISTENER ) ) { ICryptoAlpacaEnergyListener(_to).onCryptoAlpacaEnergyChanged( _id, _oldEnergy, _newEnergy ); } } } } // Root file: contracts/CryptoAlpaca/AlpacaCore.sol pragma solidity =0.6.12; // import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; // import "contracts/interfaces/IGeneScience.sol"; // import "contracts/CryptoAlpaca/AlpacaOperator.sol"; contract AlpacaCore is AlpacaOperator { /** * @dev Initializes crypto alpaca contract. * @param _alpa ALPA ERC20 contract address * @param _devAddress dev address. */ constructor( IERC20 _alpa, IGeneScience _geneScience, IAlpaSupplier _alpaSupplier, address _operator, address _devAddress ) public { alpa = _alpa; geneScience = _geneScience; operator = _operator; devAddress = _devAddress; alpaSupplier = _alpaSupplier; // start with the mythical genesis alpaca _createAlpaca(uint256(-1), 0, 0, msg.sender); } /* ========== OWNER MUTATIVE FUNCTION ========== */ /** * @dev Allows owner to withdrawal the balance available to the contract. */ function withdrawBalance(uint256 _amount, address payable _to) external onlyOwner { _to.transfer(_amount); } }
[{"inputs":[{"internalType":"contract IERC20","name":"_alpa","type":"address"},{"internalType":"contract IGeneScience","name":"_geneScience","type":"address"},{"internalType":"contract IAlpaSupplier","name":"_alpaSupplier","type":"address"},{"internalType":"address","name":"_operator","type":"address"},{"internalType":"address","name":"_devAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256[]","name":"alpacaIds","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"genes","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"energy","type":"uint256[]"}],"name":"BornBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"alpacaId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"gene","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"energy","type":"uint256"}],"name":"BornSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"alpacaId","type":"uint256"}],"name":"ClearPermissionToBreed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldCooldownEndBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCooldownEndBlock","type":"uint256"}],"name":"CooldownEndBlockChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldEnergy","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newEnergy","type":"uint256"}],"name":"EnergyChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldGene","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newGene","type":"uint256"}],"name":"GeneChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"alpacaId","type":"uint256"},{"indexed":false,"internalType":"address","name":"addr","type":"address"}],"name":"GrantedToBreed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldHatchCostMultiplierEndBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newHatchCostMultiplierEndBlock","type":"uint256"}],"name":"HatchCostMultiplierEndBlockChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"eggId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"matronId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sireId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cooldownEndBlock","type":"uint256"}],"name":"Hatched","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldHatchingCostMultiplier","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newHatchingCostMultiplier","type":"uint256"}],"name":"HatchingCostMultiplierChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"GEN0_GENERATION_FACTOR","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"alpa","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"alpaSupplier","outputs":[{"internalType":"contract IAlpaSupplier","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autoCrackingFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseHatchingFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_alpacaId","type":"uint256"}],"name":"clearPermissionToBreed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"crack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gene","type":"uint256"},{"internalType":"uint256","name":"_energy","type":"uint256"},{"internalType":"uint16","name":"_generation","type":"uint16"},{"internalType":"address","name":"_owner","type":"address"}],"name":"createAlpaca","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_genes","type":"uint256[]"},{"internalType":"uint256[]","name":"_energies","type":"uint256[]"},{"internalType":"uint16","name":"_generation","type":"uint16"},{"internalType":"address","name":"_owner","type":"address"}],"name":"createAlpacaBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devBreedingPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"geneScience","outputs":[{"internalType":"contract IGeneScience","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"generationHatchingFeeMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getAlpaca","outputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"bool","name":"isReady","type":"bool"},{"internalType":"uint256","name":"cooldownEndBlock","type":"uint256"},{"internalType":"uint256","name":"birthTime","type":"uint256"},{"internalType":"uint256","name":"matronId","type":"uint256"},{"internalType":"uint256","name":"sireId","type":"uint256"},{"internalType":"uint256","name":"hatchingCost","type":"uint256"},{"internalType":"uint256","name":"hatchingCostMultiplier","type":"uint256"},{"internalType":"uint256","name":"hatchCostMultiplierEndBlock","type":"uint256"},{"internalType":"uint256","name":"generation","type":"uint256"},{"internalType":"uint256","name":"gene","type":"uint256"},{"internalType":"uint256","name":"energy","type":"uint256"},{"internalType":"uint256","name":"state","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalAlpaca","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"uint256","name":"_sireId","type":"uint256"}],"name":"grantPermissionToBreed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"hasPermissionToBreedAsSire","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_matronId","type":"uint256"},{"internalType":"uint256","name":"_sireId","type":"uint256"}],"name":"hatch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_matronId","type":"uint256"},{"internalType":"uint256","name":"_sireId","type":"uint256"}],"name":"hatchingALPACost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hatchingDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hatchingMultiplierCoolDown","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_alpacaId","type":"uint256"}],"name":"isOwnerOf","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"isReadyToCrack","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxHatchCostMultiplier","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"newBornCoolDown","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"secondsPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_alpa","type":"address"}],"name":"setAlpaContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_autoCrackingFee","type":"uint256"}],"name":"setAutoCrackingFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_baseHatchingFee","type":"uint256"}],"name":"setBaseHatchingFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddress","type":"address"}],"name":"setDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_devBreedingPercentage","type":"uint256"}],"name":"setDevBreedingPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IGeneScience","name":"_geneScience","type":"address"}],"name":"setGeneScience","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_generationHatchingFeeMultiplier","type":"uint256"}],"name":"setGenerationHatchingFeeMultiplier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_hatchingDuration","type":"uint256"}],"name":"setHatchingDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_hatchingMultiplierCoolDown","type":"uint256"}],"name":"setHatchingMultiplierCoolDown","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_maxHatchCostMultiplier","type":"uint16"}],"name":"setMaxHatchCostMultiplier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newBornCoolDown","type":"uint256"}],"name":"setNewBornCoolDown","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_secs","type":"uint256"}],"name":"setSecondsPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newuri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newOperator","type":"address"}],"name":"transferOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint64","name":"_cooldownEndBlock","type":"uint64"}],"name":"updateAlpacaCooldownEndBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint32","name":"_newEnergy","type":"uint32"}],"name":"updateAlpacaEnergy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_gene","type":"uint256"}],"name":"updateAlpacaGene","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint64","name":"_hatchCostMultiplierEndBlock","type":"uint64"}],"name":"updateAlpacaHatchCostMultiplierEndBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint16","name":"_hatchingCostMultiplier","type":"uint16"}],"name":"updateAlpacaHatchingCostMultiplier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address payable","name":"_to","type":"address"}],"name":"withdrawBalance","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed ByteCode Sourcemap
98628:975:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46273:223;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;46273:223:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;42229:142;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42229:142:0;-1:-1:-1;;;;;;42229:142:0;;:::i;:::-;;;;;;;;;;;;;;;;;;70977:93;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;70977:93:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;70977:93:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70977:93:0;;-1:-1:-1;70977:93:0;;-1:-1:-1;;;;;70977:93:0:i;:::-;;80881:352;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;80881:352:0;;;;;;;;:::i;69556:89::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69556:89:0;-1:-1:-1;;;;;69556:89:0;;:::i;80507:264::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;80507:264:0;;;;;;;;:::i;46023:99::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46023:99:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67863:206;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67863:206:0;;:::i;63522:52::-;;;;;;;;;;;;;:::i;66904:130::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66904:130:0;;:::i;97318:158::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;97318:158:0;-1:-1:-1;;;;;97318:158:0;;:::i;48985:1220::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48985:1220:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;48985:1220:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;48985:1220:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48985:1220:0;;;;;;;;-1:-1:-1;48985:1220:0;;-1:-1:-1;;;;;48985:1220:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;48985:1220:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48985:1220:0;;;;;;;;-1:-1:-1;48985:1220:0;;-1:-1:-1;;;;;48985:1220:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;48985:1220:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48985:1220:0;;-1:-1:-1;48985:1220:0;;-1:-1:-1;;;;;48985:1220:0:i;68344:126::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68344:126:0;;:::i;63822:59::-;;;;;;;;;;;;;:::i;81981:1554::-;;;;;;;;;;;;;;;;-1:-1:-1;81981:1554:0;;;;;;;:::i;66397:98::-;;;;;;;;;;;;;:::i;71647:385::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;71647:385:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;71647:385:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71647:385:0;;;;;;;;-1:-1:-1;71647:385:0;;-1:-1:-1;;;;;71647:385:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;71647:385:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71647:385:0;;-1:-1:-1;;;71647:385:0;;;;;-1:-1:-1;;71647:385:0;;;-1:-1:-1;;;;;71647:385:0;;:::i;62704:25::-;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;62704:25:0;;;;;;;;;;;;;;96896:286;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;96896:286:0;;;;;;;:::i;64089:50::-;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;64089:50:0;;;;;;;;;;;;;;63069:41;;;;;;;;;;;;;:::i;46662:634::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;46662:634:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;46662:634:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46662:634:0;;;;;;;;-1:-1:-1;46662:634:0;;-1:-1:-1;;;;;46662:634:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;46662:634:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46662:634:0;;-1:-1:-1;46662:634:0;;-1:-1:-1;;;;;46662:634:0:i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68883:104;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68883:104:0;;:::i;93404:23::-;;;;;;;;;;;;;:::i;62596:18::-;;;;;;;;;;;;;:::i;69064:126::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69064:126:0;;:::i;78197:1315::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;78197:1315:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94861:511;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;94861:511:0;;-1:-1:-1;;;;;94861:511:0;;;;;;;;;;;;;:::i;59707:148::-;;;;;;;;;;;;;:::i;95380:498::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;95380:498:0;;;;;;;;;:::i;99455:145::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;99455:145:0;;;;;;-1:-1:-1;;;;;99455:145:0;;:::i;63220:34::-;;;;;;;;;;;;;:::i;71205:356::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71205:356:0;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;71205:356:0;;:::i;81388:233::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;81388:233:0;;:::i;59065:79::-;;;;;;;;;;;;;:::i;69262:212::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69262:212:0;-1:-1:-1;;;;;69262:212:0;;:::i;68553:193::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68553:193:0;;:::i;67294:176::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67294:176:0;;;;:::i;62479:38::-;;;;;;;;;;;;;:::i;68141:126::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68141:126:0;;:::i;47369:311::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;47369:311:0;;;;;;;;;;:::i;64229:50::-;;;;;;;;;;;;;:::i;63384:48::-;;;;;;;;;;;;;:::i;62819:33::-;;;;;;;;;;;;;:::i;79582:196::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;79582:196:0;;;;;;;:::i;83681:1763::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;83681:1763:0;;:::i;70637:176::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;70637:176:0;;;;;;;;:::i;67557:221::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67557:221:0;;:::i;67099:104::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67099:104:0;-1:-1:-1;;;;;67099:104:0;;:::i;62382:34::-;;;;;;;;;;;;;:::i;95886:552::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;95886:552:0;;;;;;-1:-1:-1;;;;;95886:552:0;;:::i;47752:160::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;47752:160:0;;;;;;;;;;:::i;63986:40::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47984:924;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;47984:924:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;47984:924:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;47984:924:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47984:924:0;;-1:-1:-1;47984:924:0;;-1:-1:-1;;;;;47984:924:0:i;64384:31::-;;;;;;;;;;;;;:::i;60010:244::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60010:244:0;-1:-1:-1;;;;;60010:244:0;;:::i;79924:257::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;79924:257:0;;:::i;96446:442::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;96446:442:0;;;;;;-1:-1:-1;;;;;96446:442:0;;:::i;46273:223::-;46351:7;-1:-1:-1;;;;;46379:21:0;;46371:77;;;;-1:-1:-1;;;46371:77:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46466:13:0;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;46466:22:0;;;;;;;;;;46273:223;;;;;:::o;42229:142::-;-1:-1:-1;;;;;;42330:33:0;42306:4;42330:33;;;:20;:33;;;;;;;;;42229:142::o;70977:93::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;71046:16:::1;71054:7;71046;:16::i;:::-;70977:93:::0;:::o;80881:352::-;81013:4;81039:21;81049:5;81056:3;81039:9;:21::i;:::-;81035:65;;;-1:-1:-1;81084:4:0;81077:11;;81035:65;81132:36;:22;81164:3;81132:31;:36::i;:::-;:93;;;;-1:-1:-1;;;;;;81185:40:0;;:31;:22;81212:3;81185:26;:31::i;:::-;-1:-1:-1;;;;;81185:40:0;;81132:93;81112:113;80881:352;-1:-1:-1;;;80881:352:0:o;69556:89::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;69625:4:::1;:12:::0;;-1:-1:-1;;;;;;69625:12:0::1;-1:-1:-1::0;;;;;69625:12:0;;;::::1;::::0;;;::::1;::::0;;69556:89::o;80507:264::-;80631:30;80641:10;80653:7;80631:9;:30::i;:::-;80623:39;;;;;;80675:42;:22;80702:7;80711:5;80675:26;:42::i;:::-;-1:-1:-1;80733:30:0;;;-1:-1:-1;;;;;80733:30:0;;;;;;80748:7;;80733:30;;;;;;;;;;80507:264;;:::o;46023:99::-;46110:4;46103:11;;;;;;;;-1:-1:-1;;46103:11:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46077:13;;46103:11;;46110:4;;46103:11;;46110:4;46103:11;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46023:99;;;:::o;67863:206::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;67995:31:::1;:66:::0;67863:206::o;63522:52::-;;;;:::o;66904:130::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;66990:16:::1;:36:::0;66904:130::o;97318:158::-;97668:12;:10;:12::i;:::-;97656:8;;-1:-1:-1;;;;;97656:8:0;;;:24;;;97648:33;;;;;;-1:-1:-1;;;;;97407:26:0;::::1;97399:35;;;::::0;::::1;;97445:8;:23:::0;;-1:-1:-1;;;;;;97445:23:0::1;-1:-1:-1::0;;;;;97445:23:0;;;::::1;::::0;;;::::1;::::0;;97318:158::o;48985:1220::-;49250:7;:14;49236:3;:10;:28;49228:81;;;;-1:-1:-1;;;49228:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;49328:16:0;;49320:66;;;;-1:-1:-1;;;49320:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49427:12;:10;:12::i;:::-;-1:-1:-1;;;;;49419:20:0;:4;-1:-1:-1;;;;;49419:20:0;;:60;;;;49443:36;49460:4;49466:12;:10;:12::i;:::-;49443:16;:36::i;:::-;49397:160;;;;-1:-1:-1;;;49397:160:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49570:16;49589:12;:10;:12::i;:::-;49570:31;;49614:60;49635:8;49645:4;49651:2;49655:3;49660:7;49669:4;49614:20;:60::i;:::-;49692:9;49687:358;49711:3;:10;49707:1;:14;49687:358;;;49743:10;49756:3;49760:1;49756:6;;;;;;;;;;;;;;49743:19;;49777:14;49794:7;49802:1;49794:10;;;;;;;;;;;;;;49777:27;;49843:126;49885:6;49843:126;;;;;;;;;;;;;;;;;:9;:13;49853:2;49843:13;;;;;;;;;;;:19;49857:4;-1:-1:-1;;;;;49843:19:0;-1:-1:-1;;;;;49843:19:0;;;;;;;;;;;;;:23;;:126;;;;;:::i;:::-;49821:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;49821:19:0;;;;;;;;;;:148;;;;50004:17;;;;;;:29;;50026:6;50004:21;:29::i;:::-;49984:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;49984:17:0;;;;;;;;;;:49;;;;-1:-1:-1;49723:3:0;;49687:358;;;;50092:2;-1:-1:-1;;;;;50062:47:0;50086:4;-1:-1:-1;;;;;50062:47:0;50076:8;-1:-1:-1;;;;;50062:47:0;;50096:3;50101:7;50062:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50122:75;50158:8;50168:4;50174:2;50178:3;50183:7;50192:4;50122:35;:75::i;:::-;48985:1220;;;;;;:::o;68344:126::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;68428:15:::1;:34:::0;68344:126::o;63822:59::-;;;;:::o;81981:1554::-;82125:7;31958:1;32564:7;;:19;;32556:63;;;;;-1:-1:-1;;;32556:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;31958:1;32697:7;:18;82246:15:::1;::::0;82170:10:::1;::::0;82233:9:::1;:28;;82225:69;;;::::0;;-1:-1:-1;;;82225:69:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;82426:43;82444:9;82455:7;82464:4;82426:17;:43::i;:::-;82365:4;::::0;:40:::1;::::0;;-1:-1:-1;;;82365:40:0;;-1:-1:-1;;;;;82365:40:0;;::::1;;::::0;::::1;::::0;82399:4:::1;82365:40:::0;;;;;;:4;;;::::1;::::0;:14:::1;::::0;:40;;;;;::::1;::::0;;;;;;;;:4;:40;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;82365:40:0;:104:::1;;82343:175;;;::::0;;-1:-1:-1;;;82343:175:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;82343:175:0;;;;;;;;;;;;;::::1;;82613:53;82636:9;82647;82658:7;82613:22;:53::i;:::-;82591:125;;;::::0;;-1:-1:-1;;;82591:125:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;82591:125:0;;;;;;;;;;;;;::::1;;82782:21;82806:7;82814:9;82806:18;;;;;;;;;;;;;;;;;;82782:42;;82928:23;82944:6;82928:15;:23::i;:::-;82920:56;;;::::0;;-1:-1:-1;;;82920:56:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;82920:56:0;;;;;;;;;;;;;::::1;;83040:19;83062:7;83070;83062:16;;;;;;;;;;;;;;;;;;83040:38;;83180:21;83196:4;83180:15;:21::i;:::-;83172:52;;;::::0;;-1:-1:-1;;;83172:52:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;83172:52:0;;;;;;;;;;;;;::::1;;83322;83341:6;83349:9;83360:4;83366:7;83322:18;:52::i;:::-;83300:125;;;::::0;;-1:-1:-1;;;83300:125:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;83498:29;83508:9;83519:7;83498:9;:29::i;:::-;31914:1:::0;32876:7;:22;83491:36;81981:1554;-1:-1:-1;;;;;;81981:1554:0:o;66397:98::-;66473:7;:14;66397:98;;:::o;71647:385::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;71858:6;-1:-1:-1;;;;;71879:25:0;::::1;71875:79;;71935:7;:5;:7::i;:::-;71921:21;;71875:79;71966:58;71985:6;71993:9;72004:11;72017:6;71966:18;:58::i;62704:25::-:0;;;-1:-1:-1;;;;;62704:25:0;;:::o;96896:286::-;97668:12;:10;:12::i;:::-;97656:8;;-1:-1:-1;;;;;97656:8:0;;;:24;;;97648:33;;;;;;97006:25:::1;97034:7;97042:3;97034:12;;;;;;;;;::::0;;;::::1;::::0;;;;::::1;::::0;;::::1;;97075:15:::0;;97101:23;;;97142:32:::1;::::0;;;;;;;::::1;::::0;;;;;97034:12;;-1:-1:-1;97075:15:0;;97154:3;;97142:32:::1;::::0;;;;;;;;;::::1;97692:1;;96896:286:::0;;:::o;64089:50::-;64137:2;64089:50;:::o;63069:41::-;;;;:::o;46662:634::-;46826:16;46887:3;:10;46868:8;:15;:29;46860:83;;;;-1:-1:-1;;;46860:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46956:30;47003:8;:15;-1:-1:-1;;;;;46989:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46989:30:0;;46956:63;;47037:9;47032:224;47056:8;:15;47052:1;:19;47032:224;;;47124:1;-1:-1:-1;;;;;47101:25:0;:8;47110:1;47101:11;;;;;;;;;;;;;;-1:-1:-1;;;;;47101:25:0;;;47093:87;;;;-1:-1:-1;;;47093:87:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47214:9;:17;47224:3;47228:1;47224:6;;;;;;;;;;;;;;47214:17;;;;;;;;;;;:30;47232:8;47241:1;47232:11;;;;;;;;;;;;;;-1:-1:-1;;;;;47214:30:0;-1:-1:-1;;;;;47214:30:0;;;;;;;;;;;;;47195:13;47209:1;47195:16;;;;;;;;;;;;;;;;;:49;47073:3;;47032:224;;;-1:-1:-1;47275:13:0;46662:634;-1:-1:-1;;;46662:634:0:o;68883:104::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;68956:15:::1;:23:::0;68883:104::o;93404:23::-;;;-1:-1:-1;;;;;93404:23:0;;:::o;62596:18::-;;;-1:-1:-1;;;;;62596:18:0;;:::o;69064:126::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;69148:15:::1;:34:::0;69064:126::o;78197:1315::-;78311:10;78336:12;78363:24;78402:17;78434:16;78465:14;78494:20;78529:30;78574:35;78624:18;78657:12;78684:14;78713:13;78754:21;78778:7;78786:3;78778:12;;;;;;;;;;;;;;;;;;78754:36;;78808:3;78803:8;;78860:12;78833:6;:23;;;;;;;;;;-1:-1:-1;;;;;78833:23:0;-1:-1:-1;;;;;78833:39:0;;;78822:51;;78903:6;:23;;;;;;;;;;-1:-1:-1;;;;;78903:23:0;-1:-1:-1;;;;;78884:42:0;;;78949:6;:16;;;;;;;;;;-1:-1:-1;;;;;78949:16:0;-1:-1:-1;;;;;78937:28:0;;;78987:6;:15;;;;;;;;;;;;78976:26;;;;79022:6;:13;;;;;;;;;;;;79013:22;;;;79061:39;79082:6;:17;;;;;;;;;;;;79061:39;;:20;:39::i;:::-;79136:29;;;;79046:54;;-1:-1:-1;;;;79136:29:0;;;;;-1:-1:-1;79218:12:0;-1:-1:-1;;;79180:34:0;;;-1:-1:-1;;;;;79180:34:0;:50;79176:109;;79272:1;79247:26;;79176:109;79327:34;;;;;79420:11;;79491:12;;;;-1:-1:-1;;;79327:34:0;;-1:-1:-1;;;;;79327:34:0;;-1:-1:-1;;;;79385:17:0;;;;;-1:-1:-1;79420:11:0;;-1:-1:-1;79451:13:0;;;;;-1:-1:-1;;;;79491:12:0;;;;;79483:21;;;;;;;79475:29;;78197:1315;;;;;;;;;;;;;;;;:::o;94861:511::-;97668:12;:10;:12::i;:::-;97656:8;;-1:-1:-1;;;;;97656:8:0;;;:24;;;97648:33;;;;;;31958:1:::1;32564:7;;:19;;32556:63;;;::::0;;-1:-1:-1;;;32556:63:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;31958:1;32697:7;:18:::0;95025:14:::2;::::0;::::2;95017:23;;;::::0;::::2;;95059:22;95069:6;95077:3;95059:9;:22::i;:::-;95051:31;;;::::0;::::2;;95095:25;95123:7;95131:3;95123:12;;;;;;;;;::::0;;;::::2;::::0;;;;::::2;::::0;;;::::2;;95165:17;::::0;::::2;::::0;;-1:-1:-1;;95193:30:0;::::2;95165:17;95193:30:::0;;::::2;::::0;;::::2;::::0;;;95241:41:::2;::::0;;95165:17;;;::::2;95241:41:::0;;;;;::::2;::::0;;;95123:12;;-1:-1:-1;95255:3:0;;95241:41:::2;::::0;;;;;;;;::::2;95293:71;95329:6;95337:3;95342:9;95293:71;;95353:10;95293:71;;:35;:71::i;:::-;-1:-1:-1::0;;31914:1:0::1;32876:7;:22:::0;-1:-1:-1;;;94861:511:0:o;59707:148::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;59814:1:::1;59798:6:::0;;59777:40:::1;::::0;-1:-1:-1;;;;;59798:6:0;;::::1;::::0;59777:40:::1;::::0;59814:1;;59777:40:::1;59845:1;59828:19:::0;;-1:-1:-1;;;;;;59828:19:0::1;::::0;;59707:148::o;95380:498::-;97668:12;:10;:12::i;:::-;97656:8;;-1:-1:-1;;;;;97656:8:0;;;:24;;;97648:33;;;;;;95527:25:::1;95555:7;95563:3;95555:12;;;;;;;;;::::0;;;::::1;::::0;;;;95613:33:::1;95555:12;::::0;;::::1;;95613:33:::0;;::::1;::::0;;::::1;95657:59:::0;;::::1;-1:-1:-1::0;;;95657:59:0;;::::1;-1:-1:-1::0;;;;95657:59:0;::::1;;::::0;;;95734:136:::1;::::0;;95613:33;;;::::1;::::0;;;::::1;95734:136:::0;;;;;::::1;::::0;;;95555:12;;-1:-1:-1;95778:3:0;;95734:136:::1;::::0;;;;;;;;::::1;97692:1;;95380:498:::0;;:::o;99455:145::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;99571:21:::1;::::0;-1:-1:-1;;;;;99571:12:0;::::1;::::0;:21;::::1;;;::::0;99584:7;;99571:21:::1;::::0;;;99584:7;99571:12;:21;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;99455:145:::0;;:::o;63220:34::-;;;;:::o;71205:356::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;71390:6;-1:-1:-1;;;;;71411:25:0;::::1;71407:79;;71467:7;:5;:7::i;:::-;71453:21;;71407:79;71498:55;71512:5;71519:7;71528:11;71541;71498:13;:55::i;81388:233::-:0;81476:32;81486:10;81498:9;81476;:32::i;:::-;81468:41;;;;;;81522:40;:22;81552:9;81522:29;:40::i;:::-;-1:-1:-1;81580:33:0;;81603:9;;81580:33;;;;;81388:233;:::o;59065:79::-;59103:7;59130:6;-1:-1:-1;;;;;59130:6:0;59065:79;:::o;69262:212::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;69351:12:::1;-1:-1:-1::0;;;;;69351:32:0::1;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;69351:34:0;69343:43:::1;;;::::0;::::1;;69440:11;:26:::0;;-1:-1:-1;;;;;;69440:26:0::1;-1:-1:-1::0;;;;;69440:26:0;;;::::1;::::0;;;::::1;::::0;;69262:212::o;68553:193::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;68682:26:::1;:56:::0;68553:193::o;67294:176::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;67414:22:::1;:48:::0;;-1:-1:-1;;67414:48:0::1;;::::0;;;::::1;::::0;;;::::1;::::0;;67294:176::o;62479:38::-;;;;:::o;68141:126::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;68225:15:::1;:34:::0;68141:126::o;47369:311::-;47488:8;-1:-1:-1;;;;;47472:24:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;47472:24:0;;;47464:78;;;;-1:-1:-1;;;47464:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47600:8;47555:18;:32;47574:12;:10;:12::i;:::-;-1:-1:-1;;;;;47555:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;47555:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;47555:53:0;;;;;;;;;;;47639:12;:10;:12::i;:::-;-1:-1:-1;;;;;47624:48:0;;47663:8;47624:48;;;;;;;;;;;;;;;;;;;;47369:311;;:::o;64229:50::-;;;;:::o;63384:48::-;;;;:::o;62819:33::-;;;-1:-1:-1;;;;;62819:33:0;;:::o;79582:196::-;79694:7;79726:44;79744:9;79755:7;79764:5;79726:17;:44::i;83681:1763::-;31958:1;32564:7;;:19;;32556:63;;;;;-1:-1:-1;;;32556:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;31958:1;32697:7;:18;;;;83803::::1;83824:7;83832:3;83824:12;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;83907:13;::::0;::::1;::::0;83824:12;;-1:-1:-1;;;;83907:13:0;::::1;-1:-1:-1::0;;;;;83907:13:0::1;83899:46;;;::::0;;-1:-1:-1;;;83899:46:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;83899:46:0;;;;;;;;;;;;;::::1;;83977:21;83964:9;::::0;::::1;::::0;-1:-1:-1;;;83964:9:0;::::1;;;:34;::::0;::::1;;;;;;;83956:62;;;::::0;;-1:-1:-1;;;83956:62:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;83956:62:0;;;;;;;;;;;;;::::1;;84114:20;84130:3;84114:15;:20::i;:::-;84106:46;;;::::0;;-1:-1:-1;;;84106:46:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;84106:46:0;;;;;;;;;;;;;::::1;;84250:12;::::0;::::1;::::0;84242:7:::1;:21:::0;;84218::::1;::::0;-1:-1:-1;;;84250:12:0;::::1;;;::::0;84242:21;::::1;;;;;;;;;;;;;;;84218:45;;84274:19;84296:7;84304:3;:10;;;;;;;;;;;;84296:19;;;;;;;;;;;;;;;;;;;;84274:41;;84328:23;;:::i;:::-;:331;::::0;;::::1;::::0;::::1;::::0;;84369:12:::1;::::0;;::::1;::::0;-1:-1:-1;;;84369:12:0;;::::1;;::::0;;::::1;84328:331:::0;;84396:15;;::::1;::::0;;;::::1;::::0;::::1;84328:331;::::0;::::1;::::0;-1:-1:-1;;;84426:13:0;;;::::1;::::0;::::1;84328:331:::0;;;;;;;84454:11;;84328:331;;;;84480:10;;::::1;::::0;::::1;84328:331:::0;;;;84505:13;;::::1;::::0;;;::::1;::::0;::::1;84328:331:::0;;;;84533:11;;::::1;::::0;::::1;84328:331:::0;;;;84559:9;;84328:331;;;;-1:-1:-1;;;84583:14:0;::::1;;;84369:12;84328:331:::0;;;84620:20:::1;::::0;::::1;::::0;84328:331;;;;;;84612:36:::1;::::0;-1:-1:-1;;;;;84620:20:0;;::::1;::::0;84612:33:::1;:36;:::i;:::-;84328:331:::0;;84849:11:::1;::::0;:26:::1;::::0;-1:-1:-1;;;84849:26:0;;84328:331;;-1:-1:-1;84745:17:0::1;::::0;;;;;-1:-1:-1;;;;;84849:11:0;;::::1;::::0;:20:::1;::::0;84328:331;;84849:26:::1;;::::0;84328:331;84849:26;;;84328:331;84745:17;84849:26:::1;;;;;;;::::0;;::::1;::::0;;;::::1;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;84849:26:0;;::::1;::::0;::::1;::::0;;;;;;84888:20;;;84919:10:::1;::::0;;::::1;:32:::0;;-1:-1:-1;;84919:32:0::1;;::::0;::::1;;::::0;;84962:9:::1;::::0;::::1;:35:::0;;84849:26;;-1:-1:-1;84849:26:0;;-1:-1:-1;84849:26:0;;-1:-1:-1;84919:10:0;84962:9;-1:-1:-1;;;;84962:35:0::1;-1:-1:-1::0;;;84919:10:0;84962:35:::1;;;;;85052:56;85095:12;85053:36;85073:15;;85053;;:19;;:36;;;;:::i;:::-;85052:42:::0;::::1;:56::i;:::-;85008:20;::::0;::::1;:111:::0;;-1:-1:-1;;85008:111:0::1;-1:-1:-1::0;;;;;85008:111:0;;::::1;;-1:-1:-1::0;;;;85130:47:0::1;-1:-1:-1::0;;;85130:47:0;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;85264:15:0;:19;85260:88:::1;;85320:15;::::0;85300:36:::1;::::0;:10:::1;::::0;:36;::::1;;;::::0;::::1;::::0;;;85320:15;85300:10;:36;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;85260:88;85397:39;::::0;;;;;::::1;::::0;::::1;::::0;;;;;85408:3;;85397:39:::1;::::0;;;;;;::::1;-1:-1:-1::0;;31914:1:0;32876:7;:22;-1:-1:-1;;;;;;83681:1763:0:o;70637:176::-;70741:4;70770:30;70780:8;70790:9;70770;:30::i;:::-;70804:1;70770:35;;70637:176;-1:-1:-1;;;70637:176:0:o;67557:221::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;67709:3:::1;67684:21;;:28;;67676:37;;;::::0;::::1;;67724:21;:46:::0;67557:221::o;67099:104::-;69832:12;:10;:12::i;:::-;69818:10;;-1:-1:-1;;;;;69818:10:0;;;:26;;;69810:35;;;;;;67171:10:::1;:24:::0;;-1:-1:-1;;;;;;67171:24:0::1;-1:-1:-1::0;;;;;67171:24:0;;;::::1;::::0;;;::::1;::::0;;67099:104::o;62382:34::-;;;;:::o;95886:552::-;97668:12;:10;:12::i;:::-;97656:8;;-1:-1:-1;;;;;97656:8:0;;;:24;;;97648:33;;;;;;96043:25:::1;96071:7;96079:3;96071:12;;;;;;;;;::::0;;;::::1;::::0;;;;96134:52:::1;96071:12;::::0;;::::1;;96134:52:::0;;::::1;::::0;;-1:-1:-1;;;;;96197:69:0;;::::1;-1:-1:-1::0;;;96197:69:0;;::::1;-1:-1:-1::0;;;;96197:69:0;::::1;;::::0;;;96284:146:::1;::::0;;96134:52;;;::::1;::::0;;;::::1;96284:146:::0;;;;;::::1;::::0;;;96071:12;;-1:-1:-1;96328:3:0;;96284:146:::1;::::0;;;;;;;;::::1;97692:1;;95886:552:::0;;:::o;47752:160::-;-1:-1:-1;;;;;47867:27:0;;;47843:4;47867:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;47752:160::o;63986:40::-;;;;;;:::o;47984:924::-;-1:-1:-1;;;;;48210:16:0;;48202:66;;;;-1:-1:-1;;;48202:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48309:12;:10;:12::i;:::-;-1:-1:-1;;;;;48301:20:0;:4;-1:-1:-1;;;;;48301:20:0;;:60;;;;48325:36;48342:4;48348:12;:10;:12::i;48325:36::-;48279:151;;;;-1:-1:-1;;;48279:151:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48443:16;48462:12;:10;:12::i;:::-;48443:31;;48487:96;48508:8;48518:4;48524:2;48528:21;48546:2;48528:17;:21::i;:::-;48551:25;48569:6;48551:17;:25::i;:::-;48578:4;48487:20;:96::i;:::-;48618:77;48642:6;48618:77;;;;;;;;;;;;;;;;;:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;48618:19:0;;;;;;;;;;;:77;:23;:77::i;:::-;48596:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;48596:19:0;;;;;;;;;;:99;;;;48726:17;;;;;;:29;;48748:6;48726:21;:29::i;:::-;48706:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;48706:17:0;;;;;;;;;;;;;:49;;;;48773:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48832:68;48863:8;48873:4;48879:2;48883;48887:6;48895:4;48832:30;:68::i;64384:31::-;;;-1:-1:-1;;;;;64384:31:0;;:::o;60010:244::-;59287:12;:10;:12::i;:::-;59277:6;;-1:-1:-1;;;;;59277:6:0;;;:22;;;59269:67;;;;;-1:-1:-1;;;59269:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;59269:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;60099:22:0;::::1;60091:73;;;;-1:-1:-1::0;;;60091:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60201:6;::::0;;60180:38:::1;::::0;-1:-1:-1;;;;;60180:38:0;;::::1;::::0;60201:6;::::1;::::0;60180:38:::1;::::0;::::1;60229:6;:17:::0;;-1:-1:-1;;;;;;60229:17:0::1;-1:-1:-1::0;;;;;60229:17:0;;;::::1;::::0;;;::::1;::::0;;60010:244::o;79924:257::-;79984:4;80001:21;80025:7;80033:3;80025:12;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;80069:12:0;;;;-1:-1:-1;;;80069:12:0;;;;:37;;;;;;;;;80068:105;;;;-1:-1:-1;80125:23:0;;;-1:-1:-1;;;;;80159:12:0;80125:47;;:23;;:47;;;;-1:-1:-1;;79924:257:0:o;96446:442::-;97668:12;:10;:12::i;:::-;97656:8;;-1:-1:-1;;;;;97656:8:0;;;:24;;;97648:33;;;;;;96579:25:::1;96607:7;96615:3;96607:12;;;;;;;;;::::0;;;::::1;::::0;;;;::::1;::::0;;;::::1;;96659:27;::::0;::::1;::::0;;-1:-1:-1;;96697:47:0;::::1;-1:-1:-1::0;;;;;96697:47:0;;::::1;::::0;;::::1;::::0;;;96762:118:::1;::::0;;96659:27;;;::::1;96762:118:::0;;;;;::::1;::::0;;;96607:12;;-1:-1:-1;96800:3:0;;96762:118:::1;::::0;;;;;;;;::::1;97692:1;;96446:442:::0;;:::o;17147:181::-;17205:7;17237:5;;;17261:6;;;;17253:46;;;;;-1:-1:-1;;;17253:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;28635:151;28719:4;28743:35;28753:3;28773;28743:9;:35::i;28409:142::-;28486:4;28510:33;28518:3;28538;28510:7;:33::i;10287:422::-;10654:20;10693:8;;;10287:422::o;40810:106::-;40898:10;40810:106;:::o;51049:88::-;51116:13;;;;:4;;:13;;;;;:::i;:::-;;51049:88;:::o;29724:162::-;29803:7;29846:30;29851:3;29871;29846:4;:30::i;28067:176::-;28156:4;28180:55;28185:3;28205;-1:-1:-1;;;;;28219:14:0;;28180:4;:55::i;:::-;28173:62;28067:176;-1:-1:-1;;;;28067:176:0:o;92354:400::-;92568:9;92563:184;92587:3;:10;92583:1;:14;92563:184;;;92623:39;92655:3;92659:1;92655:6;;;;;;;;;;;;;;92623:22;:31;;:39;;;;:::i;:::-;92619:117;;;92683:37;92713:3;92717:1;92713:6;;;;;;;;;;;;;;92683:22;:29;;:37;;;;:::i;:::-;;92619:117;92599:3;;92563:184;;;;92354:400;;;;;;:::o;18050:192::-;18136:7;18172:12;18164:6;;;;18156:29;;;;-1:-1:-1;;;18156:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;18208:5:0;;;18050:192::o;56891:799::-;57145:15;:2;-1:-1:-1;;;;;57145:13:0;;:15::i;:::-;57141:542;;;57198:2;-1:-1:-1;;;;;57181:43:0;;57225:8;57235:4;57241:3;57246:7;57255:4;57181:79;;;;;;;;;;;;;-1:-1:-1;;;;;57181:79:0;;;;;;-1:-1:-1;;;;;57181:79:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57181:79:0;;;57177:495;;;;:::i;:::-;;;;;;;;57538:14;;-1:-1:-1;;;57538:14:0;;;;;;;;;;;;;;;;;57545:6;;57538:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57177:495;57594:62;;-1:-1:-1;;;57594:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57177:495;-1:-1:-1;;;;;;57310:64:0;;-1:-1:-1;;;57310:64:0;57306:163;;57399:50;;-1:-1:-1;;;57399:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88292:1017;88425:7;88464:12;88492:7;88487:64;;88538:1;88527:12;88487:64;88563:19;88585:7;88593;88585:16;;;;;;;;;;;;;;;;;;;;;88660:15;;;;88585:16;;-1:-1:-1;88639:37:0;;-1:-1:-1;;;88660:15:0;;;;88639:20;:37::i;:::-;88712:27;;;;88612:64;;-1:-1:-1;;;;88712:27:0;;;;;-1:-1:-1;;;88754:32:0;;-1:-1:-1;;;;;88754:32:0;-1:-1:-1;;88750:94:0;;;-1:-1:-1;88831:1:0;88750:94;88856:21;88880:7;88888:9;88880:18;;;;;;;;;;;;;;;;;;;;;88959:17;;;;88880:18;;-1:-1:-1;88938:39:0;;-1:-1:-1;;;88959:17:0;;;;88938:20;:39::i;:::-;89015:29;;;;88909:68;;-1:-1:-1;;;;89015:29:0;;;;;-1:-1:-1;;;89059:34:0;;-1:-1:-1;;;;;89059:34:0;-1:-1:-1;;89055:98:0;;;-1:-1:-1;89140:1:0;89055:98;89185:116;89246:40;:18;89269:16;89246:22;:40::i;:::-;89186:36;:16;89207:14;89186:20;:36::i;89185:116::-;89165:136;88292:1017;-1:-1:-1;;;;;;;;;;;88292:1017:0:o;86459:922::-;86600:4;86676:14;86693:29;86703:7;86712:9;86693;:29::i;:::-;86676:46;;86733:24;86781:9;86776:193;;86846:42;:22;86878:9;86846:31;:42::i;:::-;:111;;;;-1:-1:-1;;;;;;86909:48:0;;:37;:22;86936:9;86909:26;:37::i;:::-;-1:-1:-1;;;;;86909:48:0;;86846:111;86807:150;;86776:193;86981:12;86996:27;87006:7;87015;86996:9;:27::i;:::-;86981:42;;87034:22;87080:7;87075:185;;87141:40;:22;87173:7;87141:31;:40::i;:::-;:107;;;;-1:-1:-1;;;;;;87202:46:0;;:35;:22;87229:7;87202:26;:35::i;:::-;-1:-1:-1;;;;;87202:46:0;;87141:107;87104:144;;87075:185;87293:9;:32;;;;87306:19;87293:32;87292:81;;;;;87344:7;:28;;;;87355:17;87344:28;87272:101;86459:922;-1:-1:-1;;;;;;;;86459:922:0:o;87592:256::-;87690:4;87750:23;87733:40;:13;;;;-1:-1:-1;;;87733:13:0;;;;:40;;;;;;;;;87732:108;;;;-1:-1:-1;;87792:24:0;;;-1:-1:-1;;;;;87826:12:0;87792:47;;:24;;:47;;87592:256::o;91543:608::-;91718:4;91797:7;91784:9;:20;91780:65;;;-1:-1:-1;91828:5:0;91821:12;;91780:65;91912:16;;;;-1:-1:-1;;;91912:16:0;;;;:27;;;:56;;-1:-1:-1;91943:14:0;;;;-1:-1:-1;;;91943:14:0;;;;:25;;91912:56;91908:101;;;-1:-1:-1;91992:5:0;91985:12;;91908:101;92023:14;;;;-1:-1:-1;;;92023:14:0;;;;:27;;;:56;;-1:-1:-1;92054:12:0;;;;-1:-1:-1;;;92054:12:0;;;;:25;;92023:56;92019:101;;;-1:-1:-1;92103:5:0;92096:12;;92019:101;-1:-1:-1;92139:4:0;91543:608;;;;;;:::o;89467:1726::-;89557:7;89638:16;89657:43;89675:9;89686:7;89695:4;89657:17;:43::i;:::-;89638:62;;89713:17;89733:44;89773:3;89733:35;89746:21;;89733:8;:12;;:35;;;;:::i;:::-;:39;;:44::i;:::-;89713:64;-1:-1:-1;89788:18:0;89809:23;:8;89713:64;89809:12;:23::i;:::-;89906:4;;89936:10;;;89906:52;;;-1:-1:-1;;;89906:52:0;;89924:10;89906:52;;;;;;;-1:-1:-1;;;;;89936:10:0;;;89906:52;;;;;;;;;;;89788:44;;-1:-1:-1;89906:4:0;;;;:17;;:52;;;;;;;;;;;;;;;:4;;:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;89906:52:0;89899:60;;;;89998:12;;:41;;;-1:-1:-1;;;89998:41:0;;90016:10;89998:41;;;;;;;;;;;;-1:-1:-1;;;;;89998:12:0;;;;:17;;:41;;;;;:12;;:41;;;;;;;;:12;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;90110:19;90132:7;90140;90132:16;;;;;;;;;;;;;;;;;;90110:38;;90159:21;90183:7;90191:9;90183:18;;;;;;;;;;;;;;;;;;90159:42;;90272:32;90299:4;90272:26;:32::i;:::-;90315:34;90342:6;90315:26;:34::i;:::-;90451:17;;;;;90483:15;;;;90451:17;-1:-1:-1;;;90451:17:0;;;;;;;90483:15;;;;:35;-1:-1:-1;90479:95:0;;;-1:-1:-1;90547:15:0;;;;-1:-1:-1;;;90547:15:0;;;;90479:95;90672:16;90691;:9;90705:1;90691:13;:16::i;:::-;90672:35;;90771:24;90798:81;90856:12;90799:37;90820:15;;90799:16;;:20;;:37;;;;:::i;90798:81::-;90771:108;;90892:13;90908:146;90933:9;90957:7;90979:8;91002:16;91033:10;90908;:146::i;:::-;91108:52;;;;;;;;;;;;;;;;;;;;90892:162;;-1:-1:-1;90892:162:0;;91108:52;;;;;;;;;91180:5;89467:1726;-1:-1:-1;;;;;;;;;;;89467:1726:0:o;74309:1292::-;74487:16;74540:1;74524:6;:13;:17;74516:26;;;;;;74578:9;:16;74561:6;:13;:33;74553:42;;;;;;74632:7;:14;74694:13;;74657:20;;-1:-1:-1;;;;;74680:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74680:28:0;;74657:51;;74719:23;74759:6;:13;-1:-1:-1;;;;;74745:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74745:28:0;;74719:54;;74791:9;74786:686;74810:6;:13;74806:1;:17;74786:686;;;74845:21;;:::i;:::-;74869:484;;;;;;;;74901:6;74908:1;74901:9;;;;;;;;;;;;;;74869:484;;;;74944:9;74954:1;74944:12;;;;;;;;;;;;;;;;;;;74869:484;;;;-1:-1:-1;;;;;74994:3:0;74869:484;;;;;-1:-1:-1;74869:484:0;;;;;;75090:1;74869:484;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64137:2;74869:484;;;;;;;;;75370:7;:21;;;;;;;;-1:-1:-1;75370:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;75370:21:0;;;;;;;;-1:-1:-1;;75370:21:0;-1:-1:-1;;;;;;;;75370:21:0;;;;;-1:-1:-1;;;;75370:21:0;-1:-1:-1;;;75370:21:0;;;;;;;;;;;-1:-1:-1;;;;75370:21:0;-1:-1:-1;;;75370:21:0;;;;;;-1:-1:-1;;;;75370:21:0;-1:-1:-1;;;75370:21:0;;;;;;;;-1:-1:-1;;;;75370:21:0;-1:-1:-1;;;75370:21:0;;;;;;;;;-1:-1:-1;;;;;75370:21:0;-1:-1:-1;;;75370:21:0;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;75370:21:0;;;;;;;;;;-1:-1:-1;;;;75370:21:0;-1:-1:-1;;;75370:21:0;;;;;;;;;;;;;;;;;;-1:-1:-1;75370:21:0;;;;;;;-1:-1:-1;;;;75370:21:0;;;;-1:-1:-1;;;75370:21:0;;;;;;;;;;;;;;;;;75431:1;75415:13;:17;75406:3;75410:1;75406:6;;;;;;;;;;;;;:26;;;;;75459:1;75447:6;75454:1;75447:9;;;;;;;;;;;;;;;;;:13;-1:-1:-1;74825:3:0;;74786:686;;;;75484:35;75495:6;75503:3;75508:6;75484:35;;;;;;;;;;;;:10;:35::i;:::-;75537:33;75547:3;75552:6;75560:9;75537:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75590:3:0;74309:1292;-1:-1:-1;;;;;;74309:1292:0:o;66503:265::-;66604:7;66649:111;66687:58;66740:4;66687:48;66703:31;;66687:11;:15;;:48;;;;:::i;:::-;:52;;:58::i;:::-;66649:15;;;:19;:111::i;97752:611::-;97929:16;:3;-1:-1:-1;;;;;97929:14:0;;:16::i;:::-;:40;;;;;97949:20;:3;-1:-1:-1;;;;;97949:18:0;;:20::i;:::-;97925:431;;;98008:115;;;-1:-1:-1;;;98008:115:0;;-1:-1:-1;;;98008:115:0;;;;;;-1:-1:-1;;;;;98008:30:0;;;;;:115;;;;;;;;;;;;;;:30;:115;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;98008:115:0;97986:359;;;98186:3;-1:-1:-1;;;;;98158:60:0;;98241:3;98267:10;98300;98158:171;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;97986:359;97752:611;;;;:::o;73348:882::-;73500:7;73520:21;;:::i;:::-;73544:427;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;73648:3:0;73544:427;;;;;;;;-1:-1:-1;73544:427:0;;;;;;73736:1;73544:427;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64137:2;73544:427;;;;;;;;73984:7;:21;;;;;;;;-1:-1:-1;73984:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;73984:21:0;;;;;;;;-1:-1:-1;;73984:21:0;-1:-1:-1;;;;;;;;73984:21:0;;;;;-1:-1:-1;;;;73984:21:0;-1:-1:-1;;;73984:21:0;;;;;;;;;;;-1:-1:-1;;;;73984:21:0;-1:-1:-1;;;73984:21:0;;;;;;-1:-1:-1;;;;73984:21:0;-1:-1:-1;;;73984:21:0;;;;;;;;-1:-1:-1;;;;73984:21:0;-1:-1:-1;;;73984:21:0;;;;;;;;;-1:-1:-1;;;;;73984:21:0;-1:-1:-1;;;73984:21:0;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;73984:21:0;;;;;;;;;;-1:-1:-1;;;;73984:21:0;-1:-1:-1;;;73984:21:0;;;;;;;;;;;;;;;;;;-1:-1:-1;73984:21:0;;;;;;;-1:-1:-1;;;;73984:21:0;;;;-1:-1:-1;;;73984:21:0;;;;;;;;;;;;;;;;;74016:19;74055:1;74038:7;:14;;;;:18;74016:40;;74069:33;74075:6;74083:11;74096:1;74069:33;;;;;;;;;;;;:5;:33::i;:::-;74152:39;;;;;;;;;;;;;;74163:11;;74152:39;;;;;;;;74211:11;73348:882;-1:-1:-1;;;;;;73348:882:0:o;87989:213::-;88057:4;;88095:35;;17611:136;17669:7;17696:43;17700:1;17703;17696:43;;;;;;;;;;;;;;;;;:3;:43::i;19448:132::-;19506:7;19533:39;19537:1;19540;19533:39;;;;;;;;;;;;;;;;;:3;:39::i;57698:198::-;57818:16;;;57832:1;57818:16;;;;;;;;;57764;;;;57818;;;;;;;;;;;;-1:-1:-1;57818:16:0;57793:41;;57856:7;57845:5;57851:1;57845:8;;;;;;;;;;;;;;;;;:18;57883:5;57698:198;-1:-1:-1;;57698:198:0:o;56121:762::-;56350:15;:2;-1:-1:-1;;;;;56350:13:0;;:15::i;:::-;56346:530;;;56403:2;-1:-1:-1;;;;;56386:38:0;;56425:8;56435:4;56441:2;56445:6;56453:4;56386:72;;;;;;;;;;;;;-1:-1:-1;;;;;56386:72:0;;;;;;-1:-1:-1;;;;;56386:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56386:72:0;;;56382:483;;;;:::i;:::-;-1:-1:-1;;;;;;56508:59:0;;-1:-1:-1;;;56508:59:0;56504:158;;56592:50;;-1:-1:-1;;;56592:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26037:125;26108:4;26132:17;;;:12;;;;;:17;;;;;;:22;;;26037:125::o;24404:1549::-;24468:4;24603:17;;;:12;;;:17;;;;;;24637:13;;24633:1313;;25069:19;;-1:-1:-1;;25022:12:0;;;;25069:23;;;;24998:21;;25069:3;;:23;;25366;;;;;;;;;;;;;;;;25337:52;;25514:9;25484:3;:12;;25497:13;25484:27;;;;;;;;;;;;;;;;:39;;:27;;;;;:39;;;;;;;;;;;;;;;25604:14;;25591:28;;:12;;;:28;;;;;25622:17;;;25591:48;;25748:18;;25591:3;;25748:18;;;;;;;;;;;;;;-1:-1:-1;;25748:18:0;;;;;;;;;;;;;;;;;;;;;25844:17;;;:12;;;:17;;;;;;25837:24;;;;25748:18;-1:-1:-1;25878:11:0;;-1:-1:-1;;;;25878:11:0;24633:1313;25929:5;25922:12;;;;;27162:149;27228:7;27255:48;27260:3;27265;27255:48;;;;;;;;;;;;;;;;;:4;:48::i;23537:692::-;23613:4;23748:17;;;:12;;;:17;;;;;;23782:13;23778:444;;-1:-1:-1;;23867:38:0;;;;;;;;;;;;;;;;;;23849:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;24064:19;;24044:17;;;:12;;;:17;;;;;;;:39;24098:11;;23778:444;24178:5;24142:3;:12;;24166:1;24155:8;:12;24142:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;24205:5;24198:12;;;;;18501:471;18559:7;18804:6;18800:47;;-1:-1:-1;18834:1:0;18827:8;;18800:47;18871:5;;;18875:1;18871;:5;:1;18895:5;;;;;:10;18887:56;;;;-1:-1:-1;;;18887:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85816:635;85899:35;;;;85937:12;-1:-1:-1;;;85899:35:0;;;-1:-1:-1;;;;;85899:35:0;:50;85895:401;;;85966:30;;;:34;;-1:-1:-1;;;;85966:34:0;-1:-1:-1;;;85966:34:0;;;85895:401;;;86056:30;;;;86125:22;;86089:1;86056:30;-1:-1:-1;;;86056:30:0;;;;;:34;;86125:22;;;86109:38;;;;86105:117;;;-1:-1:-1;86184:22:0;;;;86105:117;86238:30;;;:46;;;;;;-1:-1:-1;;;86238:46:0;-1:-1:-1;;;;86238:46:0;;;;;;;;;85895:401;86365:67;86419:12;86366:47;86397:15;;86366:26;;:30;;:47;;;;:::i;86365:67::-;86306:7;:35;;;:137;;;;;-1:-1:-1;;;;;86306:137:0;;;;;-1:-1:-1;;;;;86306:137:0;;;;;;85816:635;:::o;72262:1013::-;72452:7;72508:9;72493:26;;72480:9;:39;72472:48;;;;;;72565:7;72550:24;;72539:7;:35;72531:44;;;;;;72624:11;72609:28;;72594:11;:43;72586:52;;;;;;72651:21;;:::i;:::-;72675:448;;;;;;;;-1:-1:-1;72675:448:0;;;;;;;;;-1:-1:-1;;;;;72761:3:0;72675:448;;;;;;;;;;;;;;;72849:1;72675:448;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73136:7;:21;;;;;;;;-1:-1:-1;73136:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;73136:21:0;;;;;;;;-1:-1:-1;;73136:21:0;-1:-1:-1;;;;;;;;73136:21:0;;;;;-1:-1:-1;;;;73136:21:0;-1:-1:-1;;;73136:21:0;;;;;;;;;;;-1:-1:-1;;;;73136:21:0;-1:-1:-1;;;73136:21:0;;;;;;-1:-1:-1;;;;73136:21:0;-1:-1:-1;;;73136:21:0;;;;;;;;-1:-1:-1;;;;73136:21:0;-1:-1:-1;;;73136:21:0;;;;;;;;;-1:-1:-1;;;;;73136:21:0;-1:-1:-1;;;73136:21:0;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;73136:21:0;;;;;;;;;;-1:-1:-1;;;;73136:21:0;-1:-1:-1;;;73136:21:0;;;;;;;;;;;;;;;;;;-1:-1:-1;73136:21:0;;;;;;;-1:-1:-1;;;;73136:21:0;;;;-1:-1:-1;;;73136:21:0;;;;;;;;;;;;;;;;;73168:13;73201:1;73184:7;:14;;;;:18;73168:34;;73215:27;73221:6;73229:5;73236:1;73215:27;;;;;;;;;;;;:5;:27::i;:::-;73262:5;72262:1013;-1:-1:-1;;;;;;;72262:1013:0:o;52472:715::-;-1:-1:-1;;;;;52607:16:0;;52599:62;;;;-1:-1:-1;;;52599:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52694:7;:14;52680:3;:10;:28;52672:81;;;;-1:-1:-1;;;52672:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52766:16;52785:12;:10;:12::i;:::-;52766:31;;52810:66;52831:8;52849:1;52853:2;52857:3;52862:7;52871:4;52810:20;:66::i;:::-;52894:6;52889:126;52910:3;:10;52906:1;:14;52889:126;;;52966:37;52981:9;:17;52991:3;52995:1;52991:6;;;;;;;;;;;;;;52981:17;;;;;;;;;;;:21;52999:2;-1:-1:-1;;;;;52981:21:0;-1:-1:-1;;;;;52981:21:0;;;;;;;;;;;;;52966:7;52974:1;52966:10;;;;;;;;;;;;;;:14;;:37;;;;:::i;:::-;52942:9;:17;52952:3;52956:1;52952:6;;;;;;;;;;;;;;;;;;;52942:17;;;;;;;;;;;;;-1:-1:-1;52942:17:0;;;-1:-1:-1;;;;;52942:21:0;;;;;;;;;:61;52922:3;;52889:126;;;;53068:2;-1:-1:-1;;;;;53032:53:0;53064:1;-1:-1:-1;;;;;53032:53:0;53046:8;-1:-1:-1;;;;;53032:53:0;;53072:3;53077:7;53032:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53098:81;53134:8;53152:1;53156:2;53160:3;53165:7;53174:4;53098:35;:81::i;:::-;52472:715;;;;;:::o;5628:399::-;5692:4;5890:55;5915:7;-1:-1:-1;;;5890:24:0;:55::i;:::-;:129;;;;-1:-1:-1;5963:56:0;5988:7;-1:-1:-1;;;;;;5963:24:0;:56::i;:::-;5962:57;;5628:399;-1:-1:-1;;5628:399:0:o;51533:583::-;-1:-1:-1;;;;;51648:21:0;;51640:67;;;;-1:-1:-1;;;51640:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51720:16;51739:12;:10;:12::i;:::-;51720:31;;51764:107;51785:8;51803:1;51807:7;51816:21;51834:2;51816:17;:21::i;51764:107::-;51909:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;51909:22:0;;;;;;;;;;:34;;51936:6;51909:26;:34::i;:::-;51884:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;51884:22:0;;;;;;;;;;;;:59;;;;51959:57;;;;;;;;;;;;;51884:22;;51959:57;;;;;;;;;;;;52029:79;52060:8;52078:1;52082:7;52091:2;52095:6;52103:4;52029:30;:79::i;20076:278::-;20162:7;20197:12;20190:5;20182:28;;;;-1:-1:-1;;;20182:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20221:9;20237:1;20233;:5;;;;;;;20076:278;-1:-1:-1;;;;;20076:278:0:o;27424:319::-;27518:7;27557:17;;;:12;;;:17;;;;;;27608:12;27593:13;27585:36;;;;-1:-1:-1;;;27585:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27675:3;:12;;27699:1;27688:8;:12;27675:26;;;;;;;;;;;;;;;;;;:33;;;27668:40;;;27424:319;;;;;:::o;8116:401::-;8209:4;8391:12;8405:11;8420:50;8449:7;8458:11;8420:28;:50::i;:::-;8390:80;;;;8491:7;:17;;;;;8502:6;8491:17;8483:26;8116:401;-1:-1:-1;;;;;8116:401:0:o;9044:453::-;9225:57;;;-1:-1:-1;;;;;;9225:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9225:57:0;-1:-1:-1;;;9225:57:0;;;9331:47;;;;9168:4;;;;9225:57;9168:4;;9196:26;;-1:-1:-1;;;;;9331:18:0;;;9356:5;;9225:57;;9331:47;;;;9225:57;9331:47;;;;;;;;;;-1:-1:-1;;9331:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9293:85;;;;9409:2;9393:6;:13;:18;9389:45;;;9421:5;9428;9413:21;;;;;;;;;9389:45;9453:7;9473:6;9462:26;;;;;;;;;;;;;;;-1:-1:-1;9462:26:0;9445:44;;-1:-1:-1;9462:26:0;-1:-1:-1;;;;9044:453:0;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;110:106;195:3;191:15;;163:53::o;224:739::-;;297:4;279:16;276:26;273:2;;;305:5;;273:2;339:1;-1:-1;;318:23;414:10;357:34;-1:-1;382:8;357:34;:::i;:::-;406:19;396:2;;429:5;;396:2;460;454:9;496:16;-1:-1;;492:24;339:1;454:9;468:49;543:4;537:11;624:16;-1:-1;;;;;624:16;617:4;609:6;605:17;602:39;576:18;568:6;565:30;556:91;553:2;;;655:5;;;;;;553:2;693:6;687:4;683:17;672:28;;725:3;719:10;705:24;;576:18;740:6;737:30;734:2;;;770:5;;;;;;734:2;;847:16;841:4;837:27;807:4;814:6;802:3;794:27;;829:36;826:2;;;868:5;;;;;826:2;89:7;73:14;-1:-1;;69:28;892:50;;807:4;892:50;460:2;881:62;900:3;-1:-1;;267:696;:::o
Swarm Source
ipfs://ea1ce9b48d2f3ecc69a46bffd8f54080e003e53a80a3f73bb96af2f9c102d49a
Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
---|
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.