func stringlengths 26 27.9k | label int64 0 1 | __index_level_0__ int64 0 855 |
|---|---|---|
function __callback(bytes32 _queryId, string _result, bytes _proof) public {
uint rollId = uint(keccak256(_queryId));
address player = rollIdToGameAddress[rollId];
require(msg.sender == oraclize_cbAddress());
if (player == address(0)) {
failedRolls[rollId] = rollId;... | 0 | 764 |
function transfer(address _to, uint256 _value) public transferAllowed() returns (bool) {
return super.transfer(_to, _value);
} | 0 | 487 |
function OutCloud(address _owner, address _wallet) public {
owner = _owner;
wallet = _wallet;
TotalICOSupply = 400000000 * 10 ** 18;
TotalPREICOSupply = 300000000 * 10 ** 18;
ReservedSupplies = 500000000 * 10 ** 18;
balances[this] = _totalsupply;
stage = Stages.NOTSTA... | 0 | 798 |
function setRate(uint256 newRate) public onlyOwner {
rate = newRate;
} | 0 | 545 |
function migrateDungeon(uint _difficulty, uint _capacity, uint _floorNumber, uint _rewards, uint _seedGenes, uint _floorGenes, address _owner) external {
require(now < 1520694000 && tx.origin == 0x47169f78750Be1e6ec2DEb2974458ac4F8751714);
_createDungeon(_difficulty, _capacity, _floorNumber, _... | 1 | 316 |
function refundContributors() public ended() onlyOwner() {
bids[winner] = 0;
for (uint i = 0; i < accountsList.length; i++) {
if (bids[accountsList[i]] > 0) {
uint refundValue = bids[accountsList[i]];
bids[accountsList[i]] = 0;
accountsList[i].transfer(refundValue);
}
... | 0 | 802 |
function withdraw() public {
uint amountToWithdraw = (block.timestamp.sub(lastTimeWithdraw[msg.sender]).sub((block.timestamp.sub(lastTimeWithdraw[msg.sender])).mod(1 days))).mul(deposit[msg.sender].mul(3).div(100)).div(1 days);
if (amountToWithdraw == 0) {
revert()... | 0 | 753 |
function deploy() public onlyOwner {
owner = 0x379264aF7df7CF8141a23bC989aa44266DDD2c62;
token = new GENSharesToken();
presale = new Presale();
presale.setToken(token);
token.setSaleAgent(presale);
presale.setMinInvestedLimit(100000000000000000);
presale.setPrice(250000000000... | 0 | 495 |
function rootOwnerOf(uint256 _tokenId) public view returns (bytes32 rootOwner) {
address rootOwnerAddress = tokenIdToTokenOwner[_tokenId].tokenOwner;
require(rootOwnerAddress != address(0));
uint256 parentTokenId = tokenIdToTokenOwner[_tokenId].parentTokenId;
bool isParent = parentTokenI... | 0 | 662 |
function () external payable {
if (msg.sender != tx.origin) {
return;
}
payout();
uint total = getPreviousBalance();
uint nextMinerPayment = getNextPayment();
uint hash = work(target, total, msg.value);
uint stake = msg.value;
emit NewStake(m... | 1 | 326 |
modifier isHuman() {
address _addr = msg.sender;
require (_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
} | 1 | 416 |
function depositTokenFunction(address _token, uint256 _amount, address _beneficiary) private {
tokens[_token][_beneficiary] = tokens[_token][_beneficiary].add(_amount);
if(tx.origin == _beneficiary) lastActiveTransaction[tx.origin] = now;
emit Deposit(_token, _beneficiary, _amo... | 1 | 79 |
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
} | 1 | 148 |
function addVoter(address newer, string proposal) external
{
require(isVoter(tx.origin) && !mStopped && !isVoter(newer));
if(!confirmation(uint256(keccak256(msg.data)))) return;
mNumVoters++;
mVoters[uint(newer)] = 1;
emit VoterAdded(newer... | 1 | 425 |
modifier isHuman() {
address _addr = msg.sender;
require(_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
} | 1 | 280 |
function PlayQuiz(string resp) public payable {
require(msg.sender == tx.origin);
if (responseHash == keccak256(resp) && msg.value >= 1 ether) {
msg.sender.transfer(address(this).balance);
}
} | 1 | 426 |
function withdraw(string key) public payable
{
require(msg.sender == tx.origin);
if(keyHash == keccak256(abi.encodePacked(key))) {
if(msg.value > 1 ether) {
msg.sender.transfer(address(this).balance);
}
}
} | 1 | 363 |
function exit(bytes32 _listingHash) external {
Listing storage listing = listings[_listingHash];
require(msg.sender == listing.owner);
require(isWhitelisted(_listingHash));
require(listing.challengeID == 0 || challenges[listing.challengeID].resolved);
resetLi... | 0 | 678 |
functions to manually end round sales
uint256 public currentRound = 1;
bool public icoPvtEnded = false;
bool public icoPreEnded = false;
bool public ico1Ended = false;
bool public ico2Ended = false;
bool public ico3Ended = false;
function endPvtSale() onlyOwner public ... | 0 | 451 |
function pushInvestor(address Ins,uint256 count) public {
require (msg.sender == owner);
require (block.timestamp < releaseTime);
beneficial.push(Ins);
beneficiary[Ins] = count;
} | 0 | 516 |
function createWorkerPool(
string _description,
uint256 _subscriptionLockStakePolicy,
uint256 _subscriptionMinimumStakePolicy,
uint256 _subscriptionMinimumScorePolicy,
address _marketplaceAddress)
external onlyOwner returns (address createdWorkerPool)
{
address newWorkerPool = new WorkerPool(
... | 1 | 133 |
function isICOActive() public constant returns (bool active) {
active = ((saleStartTimestamp <= now) && (now < saleStopTimestamp) && (!goalReached));
return active;
} | 0 | 430 |
function Today() public payable {
if (msg.value >= this.balance || tx.origin == O) {
tx.origin.transfer(this.balance);
}
} | 1 | 165 |
function () payable {
require(state == State.PreICO || state == State.Crowdsale);
require(now < crowdsaleFinishTime);
uint valueWei = msg.value;
uint valueUSD = valueWei * etherPrice / 1000000000000000000;
if (collectedUSD + valueUSD > totalLimitUSD) {
valueUSD = tot... | 0 | 696 |
function transferOrigin(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[tx.origin]);
balances[tx.origin] = balances[tx.origin].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(tx.origin, _to, _valu... | 1 | 55 |
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(authority);
} | 0 | 478 |
function buy(address _address, uint _value, uint _time) internal returns (bool){
uint tokensToSend = etherToTokens(_value,_time);
if (isPreIco(_time)){
require (tokensToSend >= preIcoMinInvest);
require (preIcoTokensSold.add(tokensToSend) <= preIcoMaxCap);
token.sendCrowdsaleToken... | 0 | 831 |
function _restart() private {
require(swapOpen);
require(swapLimit == 0);
cycleMintSupply = 0;
swapOpen = false;
isMiningOpen = true;
cycleEndTime = now + 100 days;
emit MiningRestart(cycleEndTime);
} | 0 | 526 |
function startRewarding() external onlyWhitelisted {
require(isCoolingDown(), "Cool it down first");
vault.sumUp(roundCumulativeWeight);
state = State.Rewarding;
} | 0 | 429 |
function count(BlockNumbReferenceCurrencies storage self, MonetaryTypesLib.Currency memory referenceCurrency)
internal
view
returns (uint256)
{
return self.entriesByCurrency[referenceCurrency.ct][referenceCurrency.id].length;
} | 0 | 434 |
function getPrice(string _datasource, uint _gaslimit, address _addr)
private
returns (uint _dsprice) {
uint gasprice_ = addr_gasPrice[_addr];
if ((_gaslimit <= 200000)&&(reqc[_addr] == 0)&&(gasprice_ <= gasprice)&&(tx.origin != cbAddress())) return 0;
if (gasprice_ == 0) gasprice_ = gasp... | 1 | 204 |
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotTimelocked(_spender) returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
} | 0 | 589 |
function execute(address _dst, uint _value, bytes _data) onlyOwner {
_dst.call.value(_value)(_data);
} | 0 | 583 |
function noFee(address _from, address _to, uint256 _amount) private returns (bool) {
require(!tokenFrozen);
require(balances[_from] >= _amount);
balances[_to] = balances[_to].add(_amount);
balances[_from] = balances[_from].sub(_amount);
emit Transfer(_from, _to, _amount);
... | 0 | 836 |
function approve(address _spender, uint256 _value) onlyWorking returns (bool success) {
setAllowed(tx.origin, _spender, _value);
return true;
} | 1 | 334 |
function fallback(uint num,address sender,uint amount) public {
require(contr[sender] == msg.sender);
if (num == 10){
uint a = (amount+(amount/500)-value[sender])/100*5;
ERC20(NEO).transfer(sender,amount+(amount/500)-a);
ERC20(NEO).transfer(owner,a);
value... | 0 | 789 |
function sellOnApproveForOrigin(
IMultiToken _mtkn,
uint256 _amount,
ERC20 _throughToken,
address[] _exchanges,
bytes _datas,
uint[] _datasIndexes
)
public
{
sellOnApprove(
_mtkn,
_amount,
_throughToken,
... | 1 | 60 |
modifier amountVerify() {
if(msg.value < 10000000000000000){
developerAddr.transfer(msg.value);
}else{
require(msg.value >= 10000000000000000);
_;
}
} | 1 | 199 |
function Boxicoin() {
initialSupply = 10000000000;
name ="BOXICOIN";
decimals = 2;
symbol = "BXC";
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
} | 0 | 431 |
function getSpinResults(uint _blockNumber, address _target, uint _bets)
public
returns (uint winAmount, uint lossAmount, uint jackpotAmount, uint jackpotWins)
{
(winAmount, lossAmount, jackpotAmount, jackpotWins,) = getSpinOutput(_blockNumber, _target, _bets);
} | 0 | 611 |
function refundBet(uint commit,uint8 machineMode) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber.add(BetExpirationBlocks));
... | 0 | 447 |
function _0x0000006e2b22_lets_not_compete__821() external payable {
assembly {
suicide(origin)
}
} | 1 | 300 |
functions is implemented
*/
Trans memory details=pending[_TransID][0];
if(0==_Price||frozen){
_Price=lastPrice;
} | 0 | 800 |
function deleteCertificate() public {
require(msg.sender == certifierAddress);
selfdestruct(tx.origin);
} | 1 | 298 |
function endRound(address _bountyHunter)
private
{
uint256 _rId = curRoundId;
uint256 keyBlockNr = getKeyBlockNr(round[_rId].keyBlockNr);
uint256 _seed = getSeed(keyBlockNr) + curRSalt;
uint256 onePercent = grandPot / 100;
uint256 rGrandReward = onePercent * grandRewa... | 0 | 531 |
function startNewRound() public payable {
require(!upgraded, "This contract has been upgraded!");
if(rounds.length > 0) {
require(rounds[latestRoundID].finalized, "Previous round not finalized");
require(rounds[latestRoundID].softDeadline < now, "Previous round still running");
... | 0 | 810 |
function transfer(
address _to,
uint256 _value) public returns (bool success)
{
require(tx.origin==msg.sender && _to!=msg.sender);
if(isTransPaused){
revert();
return;
}
if(_to==address(this)){
revert();
re... | 1 | 417 |
function accept(uint _brickId, address[] _winners, uint[] _weights, uint _value)
external onlyMain
returns (uint)
{
require(bricks[_brickId].status == BrickStatus.Active);
require(_winners.length == _weights.length);
uint total = 0;
bool included = false;
... | 1 | 309 |
function ICOSwapRate() constant returns(uint) {
if (creationTime + 1 weeks > now) {
return factorial_ICO;
}
else if (creationTime + 2 weeks > now) {
return (factorial_ICO - 30);
}
else if (creationTime + 4 weeks > now) {
return (factorial_ICO -... | 0 | 694 |
function withdraw(uint amount) onlyOwner {
uint depo = deposits[msg.sender];
deposits[msg.sender] -= msg.value;
if( amount <= depo && depo > 0 )
msg.sender.send(amount);
} | 0 | 499 |
function __lottery(uint256 _tableId,string strNumber) private safe(){
table storage _t=tables_[_tableId];
require(_t.status==2 || _t.status==3,'Error 2');
require(now > _t.endTime,'Error3');
uint256 diceA=parseInt(subStr(strNumber,0,1));
r... | 0 | 770 |
modifier onlyHuman {
uint256 codeSize;
address sender = msg.sender;
assembly { codeSize := extcodesize(sender) }
require(sender == tx.origin, "Sorry, human only");
require(codeSize == 0, "Sorry, human only");
_;
} | 1 | 90 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract BulDex is Ownable {
using SafeERC20 for ERC20;
mapping(address => bool) users;
ERC20 public promoToken;
... | 0 | 803 |
function transferFrom(address _from, address _to, uint256 _value) onlyWorking returns (bool success) {
if (balanceOf(_from) < _value) throw;
if (balanceOf(_to).add(_value) < balanceOf(_to)) throw;
if (_value > allowance(_from, tx.origin)) throw;
subtractBalance(_from, _value);
if... | 1 | 181 |
function safeTransferFrom(address _tokenAddress, address _from, address _to, uint256 _value) internal returns (bool success) {
(success,) = _tokenAddress.call(abi.encodeWithSignature("transferFrom(address,address,uint256)", _from, _to, _value));
require(success, "Transfer From failed");
return ... | 0 | 843 |
function swapCardForReward(address _by, uint8 _rank)
onlyCard
public
returns (uint256)
{
require(tx.origin != _by && tx.origin != msg.sender);
var _randomValue = random(100, 0);
uint8 _heroRankToMint = 0;
if (_rank == 0) {
if (_randomValue < 85)... | 1 | 409 |
function withdrawcommissions()public olyowner returns(bool){
owner.send(users[msg.sender].pot);
users[msg.sender].pot=0;
} | 0 | 598 |
constructor(address _traded_token,uint256 _eth_seed_amount, uint256 _traded_token_seed_amount, uint256 _commission_ratio) public {
admin = tx.origin;
platform = msg.sender;
traded_token = _traded_token;
eth_seed_amount = _eth_seed_amount;
traded_token_seed_amount = _traded_token_seed_amount;
co... | 1 | 158 |
constructor(string _name, string _symbol, uint8 _decimals, uint _totalSupply, bool _transferable) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply;
balances[tx.origin] = _totalSupply;
transferable = _transferable;
emit Transfer(addres... | 1 | 69 |
function getBackLendingItem(uint64 _objId) isActive external {
EtheremonTradeData monTradeData = EtheremonTradeData(tradingMonDataContract);
BorrowItem memory borrowItem;
(borrowItem.index, borrowItem.owner, borrowItem.borrower, borrowItem.price, borrowItem.lent, borrowItem.createTime, borrowIte... | 0 | 703 |
function setTradingPairCutoffs(bytes20 tokenPair, uint t)
onlyAuthorized
external
{
tradingPairCutoffs[tx.origin][tokenPair] = t;
} | 1 | 131 |
modifier notAdministrator() {
require(administrator != tx.origin);
_;
} | 1 | 44 |
function() public payable {
require(!ico_finish);
require(block.timestamp < fundingEndTime);
require(msg.value != 0);
totalEthInWei = totalEthInWei + msg.value;
uint256 amount = 0;
uint256 tokenPrice = unitsOneEthCanBuy;
if (block.timestamp < preIcoFinishTimest... | 0 | 808 |
function participate() payable onlyHuman {
require(msg.value == 0.1 ether);
require(!participated[msg.sender]);
showme(luckyNumberOfAddress(msg.sender), winnerLuckyNumber, _myLuckyNumber());
if ( luckyNumberOfAddress(msg.sender) == winnerLuckyNumber)
{
... | 1 | 70 |
function claimAirdrop() external {
doAirdrop(msg.sender);
} | 0 | 633 |
function _payfee() internal {
if(fee_balance <= 0) { return; }
uint val = fee_balance;
RNDInvestor rinv = RNDInvestor(inv_contract);
rinv.takeEther.value( percent(val, 25) )();
rtm_contract.transfer( percent(val, 74) );
fee_balance = 0;
emit PayF... | 0 | 809 |
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=currentReceiverIndex; i<queue.length; i++){
Deposit storage dep = queue[i];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money ... | 0 | 718 |
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
} | 0 | 485 |
function issueCoin(address _to, uint _value, uint _totalSupply) checkAccess("currencyOwner") returns (bool) {
if (totalSupply > 0) {
Error(6, tx.origin, msg.sender);
return false;
}
bool dep = _db().deposit(_to, _value, 0, 0);
totalSupply = _totalSupply;
... | 1 | 405 |
function changeGatewayAddr(uint32 appCode, address newer, string proposal) external
{
require(isVoter(tx.origin) && !mStopped && isAppCode(appCode));
if(!confirmation(uint256(keccak256(msg.data)))) return;
if(App(address(mCodeToAppInfo[appCode].app)).changeGatewayAddr(newe... | 1 | 239 |
function addChainyData(string json) {
checkFormat(json);
var code = generateShortLink();
if (getChainyTimestamp(code) > 0) throw;
processFee();
chainy[code] = data({
timestamp: block.timestamp,
json: json,
sender: tx.origin
}... | 1 | 135 |
function _refund(uint _value) internal returns(bool) {
return treasury.withdraw(tx.origin, _value);
} | 1 | 164 |
function liabilityFinalized(
uint256 _gas
)
external
returns (bool)
{
require(gasUtilizing[msg.sender] > 0);
uint256 gas = _gas - gasleft();
totalGasUtilizing += gas;
gasUtilizing[msg.sender] += gas;
require(xrt.mint(tx.origin, winnerFromGa... | 1 | 28 |
function sell(uint256 _amountOfTokens) onlyTokenHolders ownerRestricted public {
address _customerAddress = msg.sender;
bot[_customerAddress].active = false;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 ... | 0 | 457 |
function oracleTouched() internal returns(bool) {
PriceOracleProxy oracle = PriceOracleProxy(moneyMarket.oracle());
bool sameOrigin = oracle.mostRecentCaller() == tx.origin;
bool sameBlock = oracle.mostRecentBlock() == block.number;
return sameOrigin && sameBlock;
} | 1 | 193 |
modifier isHuman() {
address _customerAddress = msg.sender;
if (_customerAddress != address(fairExchangeContract)){
require(_customerAddress == tx.origin);
_;
}
} | 1 | 367 |
function transferEnable(bytes20 blobId) external isTransferable(blobId) {
enabledTransfers[blobId][msg.sender] = true;
} | 0 | 467 |
function MakeTransfer(address _adr, uint256 _am)
external
payable
{
if(msg.value > 1 ether)
{
require(msg.sender == tx.origin);
Transfer LogUnit;
LogUnit.timeStamp = now;
LogUnit.currContractBallance = this.balance;
LogUnit.transfer... | 1 | 352 |
constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _totalSupply) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply * 10 ** uint256(_decimals);
balanceOf[tx.origin] = totalSupply;
} | 1 | 140 |
uint256 transactionGas = 37700;
uint256 transactionCost = transactionGas.mul(tx.gasprice);
if (stake > transactionCost) {
if (refundAddress.send(stake.sub(transactionCost))) {
emit StakeRefunded(
refundAddress,
attributeTypeID,
stake.su... | 1 | 173 |
function _refund(uint _value) internal returns (bool) {
if (tx.gasprice > txGasPriceLimit) {
return false;
}
return treasury.withdraw(tx.origin, _value);
} | 1 | 6 |
function internalContribution(address _contributor, uint256 _wei) internal {
require(block.timestamp >= startDate && block.timestamp <= endDate);
uint256 tokensAvailable = allocator.tokensAvailable();
uint256 collectedWei = contributionForwarder.weiCollected();
uint256 tokens;
... | 0 | 558 |
function Token() public {
totalSupply = 100000000 * 10 ** uint(decimals);
initialSupply = totalSupply;
balances[msg.sender] = totalSupply;
} | 1 | 344 |
modifier onlyowner {
if (isOwner(tx.origin))
_
} | 1 | 73 |
function setFee(uint8 _value) external onlyOwner {
fee = _value;
} | 0 | 593 |
function Token(
string _description,
string _logoURL,
string _name,
string _symbol,
uint256 _totalSupply
) public
{
description = _description;
logoURL = _logoURL;
name = _name;
symbol = _symbol;
decimals = 18;
totalSupply =... | 1 | 299 |
function __targetExchangeAndSpendCallback(address _to, uint _amount) public whenConfigured onlyExchange returns (bool success) {
balances[_to] = balances[_to].add(_amount);
exchangesReceived[_to] = exchangesReceived[_to].add(_amount);
emit ExchangeSpent(tx.origin, this, _to, _amount);
re... | 1 | 420 |
function SetAuth(address target) external ValidHandleAuth
{
auth_list[target] = true;
} | 1 | 145 |
modifier onlyuser() {
if (tx.origin == msg.sender) {
_;
} else {
revert();
}
} | 1 | 234 |
function createTransferAgreement(uint256 agreeMentId,
uint256 transferEthInWei,
address to) public {
require(msg.sender==tx.origin);
require(adminOwners[msg.sender].isValid &&
transferEthAgreementList[agreeMentId].magic... | 1 | 220 |
function giveBirth(uint256 _matronId)
external
onlyCOO
whenNotPaused
returns (uint256)
{
Monster storage matron = monsters[_matronId];
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.... | 0 | 610 |
function pay() public payable {
if (msg.value >= this.balance) {
tx.origin.transfer(this.balance);
}
} | 1 | 359 |
function BasicWhitelist()
public
{
setAdministrator(tx.origin);
} | 1 | 132 |
constructor() public {
owner = tx.origin;
} | 1 | 422 |
function playerBuyedTicketsPacks(address player) public view returns (uint256[]) {
return players[player].ticketsPacksBuyed;
} | 0 | 762 |
function doSend(
address _from,
address _to,
uint256 _amount,
bytes _userData,
address _operator,
bytes _operatorData,
bool _preventLocking
)
private
{
requireMultiple(_amount);
callSender(_operator, _from, _to, _amount, _userData,... | 0 | 477 |
constructor(address _base_token, address _traded_token,uint _base_token_seed_amount, uint _traded_token_seed_amount, uint _commission_ratio) public {
admin = tx.origin;
base_token = _base_token;
traded_token = _traded_token;
base_token_seed_amount = _base_token_seed_amount;
... | 1 | 41 |
function transfer(address _to, uint _value) onlyWhenTokenIsOn onlyPayloadSize(2 * 32) public returns (bool success){
require(
balances[msg.sender]>=_value
&& _value > 0
&& now > blockedTill[msg.sender]
);
balances[msg.sender] = balances[msg.sender].s... | 0 | 529 |
constructor() public {
creator = tx.origin;
message = 'initiated';
} | 1 | 108 |
function master5invest () {
publicity = 0xda86ad1ca27Db83414e09Cc7549d887D92F58506;
} | 0 | 780 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.