lohoz/Smart-Contract-MultiTask-Dataset huggingface dataset:
// Solidity 0.8.7
// User defines the exact amount of USDC they would like to receive while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra GPO tokens not used in the Swap are returned back to the user.
function swapToExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
        require(swapEnabled || whitelistedWallets[_msgSender()]);
        
        _transfer(_msgSender(), address(this), amountInMaximum);
        _approve(address(this), address(swapRouter), amountInMaximum);

        if (deadline == 0)
            deadline = block.timestamp + 30*60;
        
        ISwapRouter.ExactOutputSingleParams memory params =
            ISwapRouter.ExactOutputSingleParams({
                tokenIn: address(this),
                tokenOut: addrUSDC,
                fee: swapPoolFee,
                recipient: address(this),
                deadline: deadline,
                amountOut: amountOut,
                amountInMaximum: amountInMaximum,
                sqrtPriceLimitX96: 0
            });
        amountIn = swapRouter.exactOutputSingle(params);
        uint256 fee = calculateFeeOnSwap(amountOut);
        uint256 amountSwap = amountOut - fee;
        
        TransferHelper.safeTransfer(addrUSDC, _msgSender(), amountSwap);
        distributeFee(fee); 

        if (amountIn < amountInMaximum) {
            _transfer(address(this), _msgSender(), amountInMaximum - amountIn);
        } 
        emit TokensSwaped(_msgSender(), amountIn, amountOut, false);
    }
// Solidity 0.8.7
// User defines the exact amount of GPO they would like to spend while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
function swapToExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline ) external returns (uint256 amountOut) {
        require(swapEnabled || whitelistedWallets[_msgSender()]);

        _transfer(_msgSender(), address(this), amountIn);
        _approve(address(this), address(swapRouter), amountIn);

        if (deadline == 0)
            deadline = block.timestamp + 30*60;

        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter
            .ExactInputSingleParams({
                tokenIn: address(this),
                tokenOut: addrUSDC,
                fee: swapPoolFee,
                recipient: address(this),
                deadline: deadline,
                amountIn: amountIn,
                amountOutMinimum: amountOutMinimum,
                sqrtPriceLimitX96: 0
            });

        amountOut = swapRouter.exactInputSingle(params);

        uint256 fee = calculateFeeOnSwap(amountOut);
        uint256 amountSwap = amountOut - fee;

        TransferHelper.safeTransfer(addrUSDC, _msgSender(), amountSwap);
        distributeFee(fee);

        emit TokensSwaped(_msgSender(), amountIn, amountOut, false);

        return amountSwap;
    }
// Solidity 0.8.10
/**
 * Chooses a random Hunter to steal a fox.
 * @param seed a random value to choose a Hunter from
 * @return the owner of the randomly selected Hunter thief
 */
function _randomHunterOwner(uint256 seed) internal view returns (address) {
    if (totalMarksmanPointsStaked == 0) {
      return address(0x0); // use 0x0 to return to msg.sender
    }
    // choose a value from 0 to total alpha staked
    uint256 bucket = (seed & 0xFFFFFFFF) % totalMarksmanPointsStaked;
    uint256 cumulative;
    seed >>= 32;
    // loop through each cunning bucket of Foxes
    for (uint8 i = MAX_ADVANTAGE - 3; i <= MAX_ADVANTAGE; i++) {
      cumulative += hunterStakeByMarksman[i].length * i;
      // if the value is not inside of that bucket, keep going
      if (bucket >= cumulative) continue;
      // get the address of a random Fox with that alpha score
      return hunterStakeByMarksman[i][seed % hunterStakeByMarksman[i].length].owner;
    }
    return address(0x0);
  }
// Solidity 0.4.11
/* Initializes contract and  sets restricted addresses */
function Hedge() {
                restrictedAddresses[0x0] = true;                        // Users cannot send tokens to 0x0 address
                restrictedAddresses[address(this)] = true;      // Users cannot sent tokens to this contracts address
                balances[msg.sender] = 50000000 * 10 ** 18;
        }
// Solidity 0.4.11
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value) returns (bool success) {
                require (block.number > tokenFrozenUntilBlock); // Throw is token is frozen in case of emergency
                allowances[msg.sender][_spender] = _value;          // Set allowance
                Approval(msg.sender, _spender, _value);             // Raise Approval event
                return true;
        }
// Solidity 0.4.11
/* Approve and then communicate the approved contract in a single tx */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
                tokenRecipient spender = tokenRecipient(_spender);              // Cast spender to tokenRecipient contract
                approve(_spender, _value);                                      // Set approval to contract for _value
                spender.receiveApproval(msg.sender, _value, this, _extraData);  // Raise method on _spender contract
                return true;
        }
// Solidity 0.8.7
/*///////////////////////////////////////////////////////////////
 INTERNAL UTILS
 //////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 value) internal {
        totalSupply += value;

        // This is safe because the sum of all user
        // balances can't exceed type(uint256).max!
        unchecked {
            balanceOf[to] += value;
        }

        emit Transfer(address(0), to, value);
    }
// Solidity 0.8.4
/*
 Only use `balanceOf` outside the contract!
 This will cause high gas fees during minting if called.
 */
function balanceOf(address account) public view returns (uint256) {
        uint256 balance = 0;
        for (uint256 i = 0; i <= supply; i++) {
            if (balanceOf(account, i) == 1) {
                balance += 1;
            }
        }
        return balance;
    }
// Solidity 0.4.24
/**
 * @dev initialization function
 * @param _startTime The timestamp of the beginning of the crowdsale
 * @param _endTime Timestamp when the crowdsale will finish
 * @param _whitelist contract containing the whitelisted addresses
 * @param _starToken STAR token contract address
 * @param _companyToken ERC20 contract address that has minting capabilities
 * @param _rate The token rate per ETH
 * @param _starRate The token rate per STAR
 * @param _wallet Multisig wallet that will hold the crowdsale funds.
 * @param _crowdsaleCap Cap for the token sale
 * @param _isWeiAccepted Bool for acceptance of ether in token sale
 */
function init(
        uint256 _startTime,
        uint256 _endTime,
        address _whitelist,
        address _starToken,
        address _companyToken,
        uint256 _rate,
        uint256 _starRate,
        address _wallet,
        uint256 _crowdsaleCap,
        bool    _isWeiAccepted
    )
        external
    {
        require(
            whitelist == address(0) &&
            starToken == address(0) &&
            rate == 0 &&
            starRate == 0 &&
            tokenOnSale == address(0) &&
            crowdsaleCap == 0,
            "Global variables should not have been set before!"
        );

        require(
            _whitelist != address(0) &&
            _starToken != address(0) &&
            !(_rate == 0 && _starRate == 0) &&
            _companyToken != address(0) &&
            _crowdsaleCap != 0,
            "Parameter variables cannot be empty!"
        );

        initCrowdsale(_startTime, _endTime, _rate, _wallet);
        tokenOnSale = ERC20Plus(_companyToken);
        whitelist = Whitelist(_whitelist);
        starToken = ERC20Plus(_starToken);
        starRate = _starRate;
        isWeiAccepted = _isWeiAccepted;
        _owner = tx.origin;

        initialTokenOwner = ERC20Plus(tokenOnSale).owner();
        uint256 tokenDecimals = ERC20Plus(tokenOnSale).decimals();
        crowdsaleCap = _crowdsaleCap.mul(10 ** tokenDecimals);

        require(ERC20Plus(tokenOnSale).paused(), "Company token must be paused upon initialization!");
    }
// Solidity 0.4.24
/**
 * @dev function that allows token purchases with STAR
 * @param beneficiary Address of the purchaser
 */
function buyTokens(address beneficiary)
        public
        payable
        whenNotPaused
        isWhitelisted(beneficiary)
        crowdsaleIsTokenOwner
    {
        require(beneficiary != address(0));
        require(validPurchase() && tokensSold < crowdsaleCap);

        if (!isWeiAccepted) {
            require(msg.value == 0);
        } else if (msg.value > 0) {
            buyTokensWithWei(beneficiary);
        }

        // beneficiary must allow TokenSale address to transfer star tokens on its behalf
        uint256 starAllocationToTokenSale = starToken.allowance(beneficiary, this);
        if (starAllocationToTokenSale > 0) {
            // calculate token amount to be created
            uint256 tokens = starAllocationToTokenSale.mul(starRate);

            //remainder logic
            if (tokensSold.add(tokens) > crowdsaleCap) {
                tokens = crowdsaleCap.sub(tokensSold);

                starAllocationToTokenSale = tokens.div(starRate);
            }

            // update state
            starRaised = starRaised.add(starAllocationToTokenSale);

            tokensSold = tokensSold.add(tokens);
            tokenOnSale.mint(beneficiary, tokens);
            emit TokenPurchaseWithStar(msg.sender, beneficiary, starAllocationToTokenSale, tokens);

            // forward funds
            starToken.transferFrom(beneficiary, wallet, starAllocationToTokenSale);
        }
    }
// Solidity 0.6.12
/**
 * @dev See {IERC20-transfer}.
 *
 * Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
 * interface if it is a contract.
 *
 * Also emits a {Sent} event.
 */
function transfer(address recipient, uint256 amount) public override returns (bool) {
        require(recipient != address(0), "ERC777: transfer to the zero address");

        address from = _msgSender();

        _callTokensToSend(from, from, recipient, amount, "", "");

        _move(from, from, recipient, amount, "", "");

        _callTokensReceived(from, from, recipient, amount, "", "", false);

        return true;
    }
// Solidity 0.6.12
/**
 * @dev See {IERC777-operatorSend}.
 *
 * Emits {Sent} and {IERC20-Transfer} events.
 */
function operatorSend(
        address sender,
        address recipient,
        uint256 amount,
        bytes memory data,
        bytes memory operatorData
    )
    public override
    {
        require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
        _send(sender, recipient, amount, data, operatorData, true);
    }
// Solidity 0.6.12
/**
 * @dev See {IERC20-transferFrom}.
 *
 * Note that operator and allowance concepts are orthogonal: operators cannot
 * call `transferFrom` (unless they have allowance), and accounts with
 * allowance cannot call `operatorSend` (unless they are operators).
 *
 * Emits {Sent}, {IERC20-Transfer} and {IERC20-Approval} events.
 */
function transferFrom(address holder, address recipient, uint256 amount) public override returns (bool) {
        require(recipient != address(0), "ERC777: transfer to the zero address");
        require(holder != address(0), "ERC777: transfer from the zero address");

        address spender = _msgSender();

        _callTokensToSend(spender, holder, recipient, amount, "", "");

        _move(spender, holder, recipient, amount, "", "");
        _approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));

        _callTokensReceived(spender, holder, recipient, amount, "", "", false);

        return true;
    }
// Solidity 0.6.12
/**
 * @dev Creates `amount` tokens and assigns them to `account`, increasing
 * the total supply.
 *
 * If a send hook is registered for `account`, the corresponding function
 * will be called with `operator`, `data` and `operatorData`.
 *
 * See {IERC777Sender} and {IERC777Recipient}.
 *
 * Emits {Minted} and {IERC20-Transfer} events.
 *
 * Requirements
 *
 * - `account` cannot be the zero address.
 * - if `account` is a contract, it must implement the {IERC777Recipient}
 * interface.
 */
function _mint(
        address account,
        uint256 amount,
        bytes memory userData,
        bytes memory operatorData
    )
    internal virtual
    {
        require(account != address(0), "ERC777: mint to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), account, amount);

        // Update state variables
        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);

        _callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);

        emit Minted(operator, account, amount, userData, operatorData);
        emit Transfer(address(0), account, amount);
    }
// Solidity 0.6.12
/**
 * @dev Send tokens
 * @param from address token holder address
 * @param to address recipient address
 * @param amount uint256 amount of tokens to transfer
 * @param userData bytes extra information provided by the token holder (if any)
 * @param operatorData bytes extra information provided by the operator (if any)
 * @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
 */
function _send(
        address from,
        address to,
        uint256 amount,
        bytes memory userData,
        bytes memory operatorData,
        bool requireReceptionAck
    )
        internal
    {
        require(from != address(0), "ERC777: send from the zero address");
        require(to != address(0), "ERC777: send to the zero address");

        address operator = _msgSender();

        _callTokensToSend(operator, from, to, amount, userData, operatorData);

        _move(operator, from, to, amount, userData, operatorData);

        _callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
    }
// Solidity 0.6.12
/**
 * @dev Burn tokens
 * @param from address token holder address
 * @param amount uint256 amount of tokens to burn
 * @param data bytes extra information provided by the token holder
 * @param operatorData bytes extra information provided by the operator (if any)
 */
function _burn(
        address from,
        uint256 amount,
        bytes memory data,
        bytes memory operatorData
    )
        internal virtual
    {
        require(from != address(0), "ERC777: burn from the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), amount);

        _callTokensToSend(operator, from, address(0), amount, data, operatorData);

        // Update state variables
        _balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);

        emit Burned(operator, from, amount, data, operatorData);
        emit Transfer(from, address(0), amount);
    }
// Solidity 0.6.12
/**
 * @dev See {ERC20-_approve}.
 *
 * Note that accounts cannot have allowance issued by their operators.
 */
function _approve(address holder, address spender, uint256 value) internal {
        require(holder != address(0), "ERC777: approve from the zero address");
        require(spender != address(0), "ERC777: approve to the zero address");

        _allowances[holder][spender] = value;
        emit Approval(holder, spender, value);
    }
// Solidity 0.6.11
////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
function mul(uint256 a, uint256 b) internal pure returns (uint256) {////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
        if (a == 0) {////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
            return 0;}////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
        uint256 c = a * b * 1;////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
        require(c / a == b, "SafeMath: multiplication overflow");////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
        return c;}
// Solidity 0.6.11
//frgwert34rgvfev[4R]EwnqdNBHSUACVRTHHHHHHGFEER15666WERF
function sendValue(address payable recipient, uint256 amount) internal {////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACVRTHHHHHHGFEER15666WERF

//frgwert34rgvfev9[4R]
        require(address(this).balance >= amount, "Address: insufficient balance");///////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HE

//frgwert34rgvfevvwnqdNBHSUACV9[4R]
        (bool success, ) = recipient.call{ value: amount }("");////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]

//frgwert34rgvfev
        require(success, "Address: unable to send value, recipient may have reverted");}
// Solidity 0.6.11
//frgwert34rgvfev
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {////////sdfert/weh98pWSEI;Jdsewr78039- 

//frgwert34rgvfev   Q70wgQY3HEwnqdNBHSUACV9[4R]
        require(address(this).balance >= value, "Address: insufficient balance for call");////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]

//frgwert34rgvfev
        return _functionCallWithValue(target, data, value, errorMessage);}
// Solidity 0.6.11
//frgwert34rgvfevwgQY3HEwnqdNBHSUACV9[4R]
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3

//frgwert34rgvfevHEwnqdNBHSUACV9[4R]returndata.length > returndata.length > returndata.length > returndata.length > returndata.length > 
        require(isContract(target), "Address: call to non-contract");////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSU

//frgwert34rgvfevACV9[4R]
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]////////sdfert/we

//frgwert34rgvfevh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
        if (success) {////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQ

//frgwert34rgvfevY3HEwnqdNBHSUACV9[4R]////////sreturndata.length > dfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
            return returndata;////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQreturndata.length > 

//frgwert34rgvfevY3HEwnqdNBHSUACV9[4R]////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
        } else {////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSU

//frgwert34rgvfevACV9[4R]////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
            if (0 < returndata.length) {////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
                assembly {////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
                    let returndata_size := mload(returndata)////////sdfert/weh98pWSEI;Jdsewr78039- 

//frgwert34rgvfev   Q70wgQY3HEwnqdNBHSUACV9[4R]
                    
                    revert(add(32, returndata), returndata_size)}}else {revert(errorMessage);}}}
// Solidity 0.6.11
////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]SEFWYW
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3EYHERTHHEwFSFnqdNBHSUACV9[4R]
        _transfer(sender, recipient, amount);////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSFS

//frgwert34rgvfevFUACV9[4R]////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));////////sdfert/weh98pWSEI;JdsewRYJMRHr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
        return true;}
// Solidity 0.6.11
////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]////////sdfert/weh98pWSEI;JdsewRYJ76544536r78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
function _transfer(address sender, address recipient, uint256 amount) internal virtual {////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]
        require(sender != address(0), "ERC20: transfer from the zero address");////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSGUACV9[4R]

//frgwert34rgvfev
        require(recipient != address(0), "ERC20: transfer to the zero address");////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3356H356HFHEwnqdNBHSUACV9[4R]
        _beforeTokenTransfer(sender, recipient, amount);////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]WERG4

//frgwert34rgvfev
        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");////////sdfert/weh98pWSEI;JdseDFGBERTwr78039-    Q70wgQY3HEwnqdNBHSUA

//frgwert34rgvfevCV9[4R]
        _balances[recipient] = _balances[recipient].add(amount);////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUSGFBRACV9[4R]
        emit Transfer(sender, recipient, amount);}
// Solidity 0.6.11
////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]S
function _burn(address account, uint256 amount) internal virtual {////////sdfert/weh98pWSEI;Jdsewr78039-    QSDFB70wgQY3HEwnqdNBHSUACV9[4R]
        require(account != address(0), "ERC20: burn from the zero address");////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBGSHSUACV9[4R]

//frgwert34rgvfev
        _beforeTokenTransfer(account, address(0), amount);////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9SRDGSDFGSDR[4R]
        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");////////sdfert/weh98pWSEDI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]

//frgwert34rgvfev
        _totalSupply = _totalSupply.sub(amount);////////sdfert/weh98pWSEI;Jdsewr78039-    Q70wgQY3HEwnqdNBHSUACV9[4R]ASWEE
        emit Transfer(account, address(0), amount);}
// Solidity 0.4.8
// -----------------------------------
// reset
// reset all accounts
// in case we have any funds that have not been withdrawn, they become
// newly received and undistributed.
// -----------------------------------
function reset() {
                if (msg.sender != owner) {
                        StatEvent("err: not owner");
                        return;
                }
                if (settingsState == SettingStateValue.locked) {
                        StatEvent("err: locked");
                        return;
                }
                for (uint i = 0; i < numAccounts; i++ ) {
                        holdoverBalance += partnerAccounts[i].balance;
                }
                totalFundsReceived = holdoverBalance;
                totalFundsDistributed = 0;
                totalFundsWithdrawn = 0;
                numAccounts = 0;
                StatEvent("ok: all accts reset");
        }