final.sol

    // SPDX-License-Identifier: MIT
    
    
    import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.7/contracts/token/ERC20/ERC20.sol";
    
    // File: contracts/IUniswapV2Router01.sol
    
    pragma solidity >=0.6.2;
    
    interface IUniswapV2Router01 {
        function factory() external pure returns (address);
        function WETH() external pure returns (address);
    
        function addLiquidity(
            address tokenA,
            address tokenB,
            uint amountADesired,
            uint amountBDesired,
            uint amountAMin,
            uint amountBMin,
            address to,
            uint deadline
        ) external returns (uint amountA, uint amountB, uint liquidity);
        function addLiquidityETH(
            address token,
            uint amountTokenDesired,
            uint amountTokenMin,
            uint amountETHMin,
            address to,
            uint deadline
        ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
        function removeLiquidity(
            address tokenA,
            address tokenB,
            uint liquidity,
            uint amountAMin,
            uint amountBMin,
            address to,
            uint deadline
        ) external returns (uint amountA, uint amountB);
        function removeLiquidityETH(
            address token,
            uint liquidity,
            uint amountTokenMin,
            uint amountETHMin,
            address to,
            uint deadline
        ) external returns (uint amountToken, uint amountETH);
        function removeLiquidityWithPermit(
            address tokenA,
            address tokenB,
            uint liquidity,
            uint amountAMin,
            uint amountBMin,
            address to,
            uint deadline,
            bool approveMax, uint8 v, bytes32 r, bytes32 s
        ) external returns (uint amountA, uint amountB);
        function removeLiquidityETHWithPermit(
            address token,
            uint liquidity,
            uint amountTokenMin,
            uint amountETHMin,
            address to,
            uint deadline,
            bool approveMax, uint8 v, bytes32 r, bytes32 s
        ) external returns (uint amountToken, uint amountETH);
        function swapExactTokensForTokens(
            uint amountIn,
            uint amountOutMin,
            address[] calldata path,
            address to,
            uint deadline
        ) external returns (uint[] memory amounts);
        function swapTokensForExactTokens(
            uint amountOut,
            uint amountInMax,
            address[] calldata path,
            address to,
            uint deadline
        ) external returns (uint[] memory amounts);
        function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
            external
            payable
            returns (uint[] memory amounts);
        function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
            external
            returns (uint[] memory amounts);
        function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
            external
            returns (uint[] memory amounts);
        function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
            external
            payable
            returns (uint[] memory amounts);
    
        function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
        function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
        function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
        function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
        function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
    }
    // File: contracts/IUniswapV2Router02.sol
    
    pragma solidity >=0.6.2;
    
    
    interface IUniswapV2Router02 is IUniswapV2Router01 {
        function removeLiquidityETHSupportingFeeOnTransferTokens(
            address token,
            uint liquidity,
            uint amountTokenMin,
            uint amountETHMin,
            address to,
            uint deadline
        ) external returns (uint amountETH);
        function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
            address token,
            uint liquidity,
            uint amountTokenMin,
            uint amountETHMin,
            address to,
            uint deadline,
            bool approveMax, uint8 v, bytes32 r, bytes32 s
        ) external returns (uint amountETH);
    
        function swapExactTokensForTokensSupportingFeeOnTransferTokens(
            uint amountIn,
            uint amountOutMin,
            address[] calldata path,
            address to,
            uint deadline
        ) external;
        function swapExactETHForTokensSupportingFeeOnTransferTokens(
            uint amountOutMin,
            address[] calldata path,
            address to,
            uint deadline
        ) external payable;
        function swapExactTokensForETHSupportingFeeOnTransferTokens(
            uint amountIn,
            uint amountOutMin,
            address[] calldata path,
            address to,
            uint deadline
        ) external;
    }
    // File: contracts/IUniswapV2Factory.sol
    
    pragma solidity >=0.5.0;
    
    interface IUniswapV2Factory {
        event PairCreated(address indexed token0, address indexed token1, address pair, uint);
    
        function feeTo() external view returns (address);
        function feeToSetter() external view returns (address);
    
        function getPair(address tokenA, address tokenB) external view returns (address pair);
        function allPairs(uint) external view returns (address pair);
        function allPairsLength() external view returns (uint);
    
        function createPair(address tokenA, address tokenB) external returns (address pair);
    
        function setFeeTo(address) external;
        function setFeeToSetter(address) external;
    }
    // File: contracts/IUniswapV2Pair.sol
    
    pragma solidity >=0.5.0;
    
    interface IUniswapV2Pair {
        event Approval(address indexed owner, address indexed spender, uint value);
        event Transfer(address indexed from, address indexed to, uint value);
    
        function name() external pure returns (string memory);
        function symbol() external pure returns (string memory);
        function decimals() external pure returns (uint8);
        function totalSupply() external view returns (uint);
        function balanceOf(address owner) external view returns (uint);
        function allowance(address owner, address spender) external view returns (uint);
    
        function approve(address spender, uint value) external returns (bool);
        function transfer(address to, uint value) external returns (bool);
        function transferFrom(address from, address to, uint value) external returns (bool);
    
        function DOMAIN_SEPARATOR() external view returns (bytes32);
        function PERMIT_TYPEHASH() external pure returns (bytes32);
        function nonces(address owner) external view returns (uint);
    
        function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
    
        event Mint(address indexed sender, uint amount0, uint amount1);
        event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
        event Swap(
            address indexed sender,
            uint amount0In,
            uint amount1In,
            uint amount0Out,
            uint amount1Out,
            address indexed to
        );
        event Sync(uint112 reserve0, uint112 reserve1);
    
        function MINIMUM_LIQUIDITY() external pure returns (uint);
        function factory() external view returns (address);
        function token0() external view returns (address);
        function token1() external view returns (address);
        function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
        function price0CumulativeLast() external view returns (uint);
        function price1CumulativeLast() external view returns (uint);
        function kLast() external view returns (uint);
    
        function mint(address to) external returns (uint liquidity);
        function burn(address to) external returns (uint amount0, uint amount1);
        function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
        function skim(address to) external;
        function sync() external;
    
        function initialize(address, address) external;
    }
    // File: contracts/IterableMapping.sol
    
    // 
    // pragma solidity ^0.7.6;
    
    library IterableMapping {
        // Iterable mapping from address to uint;
        struct Map {
            address[] keys;
            mapping(address => uint) values;
            mapping(address => uint) indexOf;
            mapping(address => bool) inserted;
        }
    
        function get(Map storage map, address key) public view returns (uint) {
            return map.values[key];
        }
    
        function getIndexOfKey(Map storage map, address key) public view returns (int) {
            if(!map.inserted[key]) {
                return -1;
            }
            return int(map.indexOf[key]);
        }
    
        function getKeyAtIndex(Map storage map, uint index) public view returns (address) {
            return map.keys[index];
        }
    
    
    
        function size(Map storage map) public view returns (uint) {
            return map.keys.length;
        }
    
        function set(Map storage map, address key, uint val) public {
            if (map.inserted[key]) {
                map.values[key] = val;
            } else {
                map.inserted[key] = true;
                map.values[key] = val;
                map.indexOf[key] = map.keys.length;
                map.keys.push(key);
            }
        }
    
        function remove(Map storage map, address key) public {
            if (!map.inserted[key]) {
                return;
            }
    
            delete map.inserted[key];
            delete map.values[key];
    
            uint index = map.indexOf[key];
            uint lastIndex = map.keys.length - 1;
            address lastKey = map.keys[lastIndex];
    
            map.indexOf[lastKey] = index;
            delete map.indexOf[key];
    
            map.keys[index] = lastKey;
            map.keys.pop();
        }
    }
    // File: contracts/Ownable.sol
    
    // 
    
    // pragma solidity ^0.7.0;
    
    /**
     * @dev Contract module which provides a basic access control mechanism, where
     * there is an account (an owner) that can be granted exclusive access to
     * specific functions.
     *
     * By default, the owner account will be the one that deploys the contract. This
     * can later be changed with {transferOwnership}.
     *
     * This module is used through inheritance. It will make available the modifier
     * `onlyOwner`, which can be applied to your functions to restrict their use to
     * the owner.
     */
    abstract contract Ownable is Context {
        address private _owner;
    
        event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
        /**
         * @dev Initializes the contract setting the deployer as the initial owner.
         */
        constructor () {
            address msgSender = _msgSender();
            _owner = msgSender;
            emit OwnershipTransferred(address(0), msgSender);
        }
    
        /**
         * @dev Returns the address of the current owner.
         */
        function owner() public view virtual returns (address) {
            return _owner;
        }
    
        /**
         * @dev Throws if called by any account other than the owner.
         */
        modifier onlyOwner() {
            require(owner() == _msgSender(), "Ownable: caller is not the owner");
            _;
        }
    
        /**
         * @dev Leaves the contract without owner. It will not be possible to call
         * `onlyOwner` functions anymore. Can only be called by the current owner.
         *
         * NOTE: Renouncing ownership will leave the contract without an owner,
         * thereby removing any functionality that is only available to the owner.
         */
        function renounceOwnership() public virtual onlyOwner {
            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;
        }
    }
    // File: contracts/IDividendPayingTokenOptional.sol
    
    // pragma solidity ^0.7.6;
    
    
    /// @title Dividend-Paying Token Optional Interface
    /// @author Roger Wu (https://github.com/roger-wu)
    /// @dev OPTIONAL functions for a dividend-paying token contract.
    interface IDividendPayingTokenOptional {
      /// @notice View the amount of dividend in wei that an address can withdraw.
      /// @param _owner The address of a token holder.
      /// @return The amount of dividend in wei that `_owner` can withdraw.
      function withdrawableDividendOf(address _owner) external view returns(uint256);
    
      /// @notice View the amount of dividend in wei that an address has withdrawn.
      /// @param _owner The address of a token holder.
      /// @return The amount of dividend in wei that `_owner` has withdrawn.
      function withdrawnDividendOf(address _owner) external view returns(uint256);
    
      /// @notice View the amount of dividend in wei that an address has earned in total.
      /// @dev accumulativeDividendOf(_owner) = withdrawableDividendOf(_owner) + withdrawnDividendOf(_owner)
      /// @param _owner The address of a token holder.
      /// @return The amount of dividend in wei that `_owner` has earned in total.
      function accumulativeDividendOf(address _owner) external view returns(uint256);
    }
    // File: contracts/IDividendPayingToken.sol
    
    // pragma solidity ^0.7.6;
    
    
    /// @title Dividend-Paying Token Interface
    /// @author Roger Wu (https://github.com/roger-wu)
    /// @dev An interface for a dividend-paying token contract.
    interface IDividendPayingToken {
      /// @notice View the amount of dividend in wei that an address can withdraw.
      /// @param _owner The address of a token holder.
      /// @return The amount of dividend in wei that `_owner` can withdraw.
      function dividendOf(address _owner) external view returns(uint256);
    
      /// @notice Distributes ether to token holders as dividends.
      /// @dev SHOULD distribute the paid ether to token holders as dividends.
      ///  SHOULD NOT directly transfer ether to token holders in this function.
      ///  MUST emit a `DividendsDistributed` event when the amount of distributed ether is greater than 0.
      function distributeDividends() external payable;
    
      /// @notice Withdraws the ether distributed to the sender.
      /// @dev SHOULD transfer `dividendOf(msg.sender)` wei to `msg.sender`, and `dividendOf(msg.sender)` SHOULD be 0 after the transfer.
      ///  MUST emit a `DividendWithdrawn` event if the amount of ether transferred is greater than 0.
      function withdrawDividend() external;
    
      /// @dev This event MUST emit when ether is distributed to token holders.
      /// @param from The address which sends ether to this contract.
      /// @param weiAmount The amount of distributed ether in wei.
      event DividendsDistributed(
        address indexed from,
        uint256 weiAmount
      );
    
      /// @dev This event MUST emit when an address withdraws their dividend.
      /// @param to The address which withdraws ether from this contract.
      /// @param weiAmount The amount of withdrawn ether in wei.
      event DividendWithdrawn(
        address indexed to,
        uint256 weiAmount
      );
    }
    // File: contracts/SafeMathInt.sol
    
    // pragma solidity ^0.7.6;
    
    /**
     * @title SafeMathInt
     * @dev Math operations with safety checks that revert on error
     * @dev SafeMath adapted for int256
     * Based on code of  https://github.com/RequestNetwork/requestNetwork/blob/master/packages/requestNetworkSmartContracts/contracts/base/math/SafeMathInt.sol
     */
    library SafeMathInt {
      function mul(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when multiplying INT256_MIN with -1
        // https://github.com/RequestNetwork/requestNetwork/issues/43
        require(!(a == - 2**255 && b == -1) && !(b == - 2**255 && a == -1));
    
        int256 c = a * b;
        require((b == 0) || (c / b == a));
        return c;
      }
    
      function div(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when dividing INT256_MIN by -1
        // https://github.com/RequestNetwork/requestNetwork/issues/43
        require(!(a == - 2**255 && b == -1) && (b > 0));
    
        return a / b;
      }
    
      function sub(int256 a, int256 b) internal pure returns (int256) {
        require((b >= 0 && a - b <= a) || (b < 0 && a - b > a));
    
        return a - b;
      }
    
      function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));
        return c;
      }
    
      function toUint256Safe(int256 a) internal pure returns (uint256) {
        require(a >= 0);
        return uint256(a);
      }
    }
    // File: contracts/SafeMathUint.sol
    
    // pragma solidity ^0.7.6;
    
    /**
     * @title SafeMathUint
     * @dev Math operations with safety checks that revert on error
     */
    library SafeMathUint {
      function toInt256Safe(uint256 a) internal pure returns (int256) {
        int256 b = int256(a);
        require(b >= 0);
        return b;
      }
    }
    
    
    // File: contracts/AkuAkuDividendPayingToken.sol
    
    // 
    
    // pragma solidity ^0.7.6;
    
    
    
    
    
    
    
    
    
    /// @title Dividend-Paying Token
    /// @author Roger Wu (https://github.com/roger-wu)
    /// @dev A mintable ERC20 token that allows anyone to pay and distribute ether
    ///  to token holders as dividends and allows token holders to withdraw their dividends.
    ///  Reference: the source code of PoWH3D: https://etherscan.io/address/0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe#code
    contract DividendPayingToken is ERC20, IDividendPayingToken, IDividendPayingTokenOptional {
      using SafeMath for uint256;
      using SafeMathUint for uint256;
      using SafeMathInt for int256;
    
      // With `magnitude`, we can properly distribute dividends even if the amount of received ether is small.
      // For more discussion about choosing the value of `magnitude`,
      //  see https://github.com/ethereum/EIPs/issues/1726#issuecomment-472352728
      uint256 constant internal magnitude = 2**128;
    
      uint256 internal magnifiedDividendPerShare;
      uint256 internal lastAmount;
      
      address public immutable USDTToken = address(0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56);
    
      // About dividendCorrection:
      // If the token balance of a `_user` is never changed, the dividend of `_user` can be computed with:
      //   `dividendOf(_user) = dividendPerShare * balanceOf(_user)`.
      // When `balanceOf(_user)` is changed (via minting/burning/transferring tokens),
      //   `dividendOf(_user)` should not be changed,
      //   but the computed value of `dividendPerShare * balanceOf(_user)` is changed.
      // To keep the `dividendOf(_user)` unchanged, we add a correction term:
      //   `dividendOf(_user) = dividendPerShare * balanceOf(_user) + dividendCorrectionOf(_user)`,
      //   where `dividendCorrectionOf(_user)` is updated whenever `balanceOf(_user)` is changed:
      //   `dividendCorrectionOf(_user) = dividendPerShare * (old balanceOf(_user)) - (new balanceOf(_user))`.
      // So now `dividendOf(_user)` returns the same value before and after `balanceOf(_user)` is changed.
      mapping(address => int256) internal magnifiedDividendCorrections;
      mapping(address => uint256) internal withdrawnDividends;
    
      uint256 public totalDividendsDistributed;
    
      constructor(string memory _name, string memory _symbol) public ERC20(_name, _symbol) {
    
      }
      
    
      receive() external payable {
      }
    
      /// @notice Distributes ether to token holders as dividends.
      /// @dev It reverts if the total supply of tokens is 0.
      /// It emits the `DividendsDistributed` event if the amount of received ether is greater than 0.
      /// About undistributed ether:
      ///   In each distribution, there is a small amount of ether not distributed,
      ///     the magnified amount of which is
      ///     `(msg.value * magnitude) % totalSupply()`.
      ///   With a well-chosen `magnitude`, the amount of undistributed ether
      ///     (de-magnified) in a distribution can be less than 1 wei.
      ///   We can actually keep track of the undistributed ether in a distribution
      ///     and try to distribute it in the next distribution,
      ///     but keeping track of such data on-chain costs much more than
      ///     the saved ether, so we don't do that.
      function distributeDividends() public override payable {
        require(totalSupply() > 0);
    
        if (msg.value > 0) {
          magnifiedDividendPerShare = magnifiedDividendPerShare.add(
            (msg.value).mul(magnitude) / totalSupply()
          );
          emit DividendsDistributed(msg.sender, msg.value);
    
          totalDividendsDistributed = totalDividendsDistributed.add(msg.value);
        }
      }
      
    
      function distributeUSDTDividends(uint256 amount) public {
        require(totalSupply() > 0);
    
        if (amount > 0) {
          magnifiedDividendPerShare = magnifiedDividendPerShare.add(
            (amount).mul(magnitude) / totalSupply()
          );
          emit DividendsDistributed(msg.sender, amount);
    
          totalDividendsDistributed = totalDividendsDistributed.add(amount);
        }
      }
    
      /// @notice Withdraws the ether distributed to the sender.
      /// @dev It emits a `DividendWithdrawn` event if the amount of withdrawn ether is greater than 0.
      function withdrawDividend() public virtual override {
        _withdrawDividendOfUser(msg.sender);
      }
    
      /// @notice Withdraws the ether distributed to the sender.
      /// @dev It emits a `DividendWithdrawn` event if the amount of withdrawn ether is greater than 0.
      function _withdrawDividendOfUser(address payable user) internal returns (uint256) {
        uint256 _withdrawableDividend = withdrawableDividendOf(user);
        if (_withdrawableDividend > 0) {
          withdrawnDividends[user] = withdrawnDividends[user].add(_withdrawableDividend);
          emit DividendWithdrawn(user, _withdrawableDividend);
          bool success = IERC20(USDTToken).transfer(user, _withdrawableDividend);
    
          if(!success) {
            withdrawnDividends[user] = withdrawnDividends[user].sub(_withdrawableDividend);
            return 0;
          }
    
          return _withdrawableDividend;
        }
    
        return 0;
      }
    
    
      /// @notice View the amount of dividend in wei that an address can withdraw.
      /// @param _owner The address of a token holder.
      /// @return The amount of dividend in wei that `_owner` can withdraw.
      function dividendOf(address _owner) public view override returns(uint256) {
        return withdrawableDividendOf(_owner);
      }
    
      /// @notice View the amount of dividend in wei that an address can withdraw.
      /// @param _owner The address of a token holder.
      /// @return The amount of dividend in wei that `_owner` can withdraw.
      function withdrawableDividendOf(address _owner) public view override returns(uint256) {
        return accumulativeDividendOf(_owner).sub(withdrawnDividends[_owner]);
      }
    
      /// @notice View the amount of dividend in wei that an address has withdrawn.
      /// @param _owner The address of a token holder.
      /// @return The amount of dividend in wei that `_owner` has withdrawn.
      function withdrawnDividendOf(address _owner) public view override returns(uint256) {
        return withdrawnDividends[_owner];
      }
    
    
      /// @notice View the amount of dividend in wei that an address has earned in total.
      /// @dev accumulativeDividendOf(_owner) = withdrawableDividendOf(_owner) + withdrawnDividendOf(_owner)
      /// = (magnifiedDividendPerShare * balanceOf(_owner) + magnifiedDividendCorrections[_owner]) / magnitude
      /// @param _owner The address of a token holder.
      /// @return The amount of dividend in wei that `_owner` has earned in total.
      function accumulativeDividendOf(address _owner) public view override returns(uint256) {
        return magnifiedDividendPerShare.mul(balanceOf(_owner)).toInt256Safe()
          .add(magnifiedDividendCorrections[_owner]).toUint256Safe() / magnitude;
      }
    
      /// @dev Internal function that transfer tokens from one address to another.
      /// Update magnifiedDividendCorrections to keep dividends unchanged.
      /// @param from The address to transfer from.
      /// @param to The address to transfer to.
      /// @param value The amount to be transferred.
      function _transfer(address from, address to, uint256 value) internal virtual override {
        require(false);
    
        int256 _magCorrection = magnifiedDividendPerShare.mul(value).toInt256Safe();
        magnifiedDividendCorrections[from] = magnifiedDividendCorrections[from].add(_magCorrection);
        magnifiedDividendCorrections[to] = magnifiedDividendCorrections[to].sub(_magCorrection);
      }
    
      /// @dev Internal function that mints tokens to an account.
      /// Update magnifiedDividendCorrections to keep dividends unchanged.
      /// @param account The account that will receive the created tokens.
      /// @param value The amount that will be created.
      function _mint(address account, uint256 value) internal override {
        super._mint(account, value);
    
        magnifiedDividendCorrections[account] = magnifiedDividendCorrections[account]
          .sub( (magnifiedDividendPerShare.mul(value)).toInt256Safe() );
      }
    
      /// @dev Internal function that burns an amount of the token of a given account.
      /// Update magnifiedDividendCorrections to keep dividends unchanged.
      /// @param account The account whose tokens will be burnt.
      /// @param value The amount that will be burnt.
      function _burn(address account, uint256 value) internal override {
        super._burn(account, value);
    
        magnifiedDividendCorrections[account] = magnifiedDividendCorrections[account]
          .add( (magnifiedDividendPerShare.mul(value)).toInt256Safe() );
      }
    
      function _setBalance(address account, uint256 newBalance) internal {
        uint256 currentBalance = balanceOf(account);
    
        if(newBalance > currentBalance) {
          uint256 mintAmount = newBalance.sub(currentBalance);
          _mint(account, mintAmount);
        } else if(newBalance < currentBalance) {
          uint256 burnAmount = currentBalance.sub(newBalance);
          _burn(account, burnAmount);
        }
      }
    }
    
    // File: contracts/AkuAku.sol
    
    // 
    
    // pragma solidity ^0.7.6;
    
    contract MiniBabyUSDT is ERC20, Ownable {
        using SafeMath for uint256;
    
        IUniswapV2Router02 public uniswapV2Router;
        address public immutable uniswapV2Pair;
    
        address public immutable USDTToken = address(0x55d398326f99059fF775485246999027B3197955);
    
        bool private swapping;
    
        MiniBabyUSDTDividendTracker public dividendTracker;
    
        address public liquidityWallet;
    
        uint256 private _totalSup = 1000000000000 * (10**18);
    
        uint256 public maxSellTransactionAmount = (_totalSup * 1) / 400; //0.25% of total supply
        uint256 public swapTokensAtAmount = (_totalSup * 1) / 2000; // 0.05% of total supply
        uint256 public _maxWalletToken = (_totalSup * 2) / 100; // 2% of total supply
        
        //uint256 public maxSellTransactionAmount = 1000000 * (10**18);
        //uint256 public swapTokensAtAmount = 200000 * (10**18);
    
        uint256 public BNBRewardsFee;
        uint256 public liquidityFee;
        uint256 public marketingFee;
        uint256 public jackPotFee;
        uint256 public totalFees;
    
        address payable _marketingWallet;
        address payable _jackpotWallet;
    
        // sells have fees of 12 and 6 (10 * 1.2 and 5 * 1.2)
        uint256 public immutable sellFeeIncreaseFactor = 120;
    
        // use by default 300,000 gas to process auto-claiming dividends
        uint256 public gasForProcessing = 300000;
        
        address public presaleAddress = address(0);
    
        // timestamp for when the token can be traded freely on PanackeSwap
        bool public tradingEnabled = false;
    
        // exlcude from fees and max transaction amount
        mapping (address => bool) private _isExcludedFromFees;
    
        // addresses that can make transfers before presale is over
        mapping (address => bool) private canTransferBeforeTradingIsEnabled;
    
        // store addresses that a automatic market maker pairs. Any transfer *to* these addresses
        // could be subject to a maximum transfer amount
        mapping (address => bool) public automatedMarketMakerPairs;
    
        event UpdateDividendTracker(address indexed newAddress, address indexed oldAddress);
    
        event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
    
        event ExcludeFromFees(address indexed account, bool isExcluded);
        event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
    
        event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
    
        event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
    
        event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
    
        event FixedSaleBuy(address indexed account, uint256 indexed amount, bool indexed earlyParticipant, uint256 numberOfBuyers);
    
        event SwapAndLiquify(
            uint256 tokensSwapped,
            uint256 ethReceived,
            uint256 tokensIntoLiqudity
        );
    
        event SendDividends(
        	uint256 tokensSwapped,
        	uint256 amount
        );
    
        event ProcessedDividendTracker(
        	uint256 iterations,
        	uint256 claims,
            uint256 lastProcessedIndex,
        	bool indexed automatic,
        	uint256 gas,
        	address indexed processor
        );
    
        constructor() public ERC20("MiniBabyUSDT", "MiniBabyUSDT") {
            uint256 _BNBRewardsFee = 8;
            uint256 _liquidityFee = 4;
            uint256 _marketingFee = 2;
            uint256 _jackPotFee = 2;
    
            BNBRewardsFee = _BNBRewardsFee;
            liquidityFee = _liquidityFee;
            marketingFee = _marketingFee;
            jackPotFee = _jackPotFee;
            totalFees = _BNBRewardsFee.add(_liquidityFee).add(_marketingFee).add(_jackPotFee);
    
        	dividendTracker = new MiniBabyUSDTDividendTracker();
    
            _marketingWallet = 0x1d306B3c0559b46d968C9F9b4747f70290cFB423;
            _jackpotWallet = 0xCDe950560e09Af953393e37d8c6e2009841cF37C;
        	liquidityWallet = owner();
    
        	
        	IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
             // Create a uniswap pair for this new token
            address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
                .createPair(address(this), _uniswapV2Router.WETH());
    
            uniswapV2Router = _uniswapV2Router;
            uniswapV2Pair = _uniswapV2Pair;
    
            _setAutomatedMarketMakerPair(_uniswapV2Pair, true);
    
            // exclude from receiving dividends
            dividendTracker.excludeFromDividends(address(dividendTracker));
            dividendTracker.excludeFromDividends(address(this));
            dividendTracker.excludeFromDividends(owner());
            dividendTracker.excludeFromDividends(address(_uniswapV2Router));
            
    
            // exclude from paying fees or having max transaction amount
            excludeFromFees(liquidityWallet, true);
            excludeFromFees(_jackpotWallet, true);
            excludeFromFees(_marketingWallet, true);
            excludeFromFees(address(this), true);
    
            // enable owner and fixed-sale wallet to send tokens before presales are over
            canTransferBeforeTradingIsEnabled[owner()] = true;
            /*
                _mint is an internal function in ERC20.sol that is only called here,
                and CANNOT be called ever again
            */
            //_mint(owner(), 1000000000 * (10**18));
    
            _mint(owner(), _totalSup);
        }
    
        receive() external payable {
    
      	}
      	
        function updateMaxAmount(uint256 newNum) public onlyOwner {
            require(maxSellTransactionAmount != newNum);
            maxSellTransactionAmount = newNum;
        }
    
    
        function setTradingIsEnabled() public onlyOwner {
            tradingEnabled = true;
        }
        
       function updateLiquidityFee(uint256 percent) public onlyOwner {
            liquidityFee = percent;
            totalFees = BNBRewardsFee.add(liquidityFee).add(marketingFee).add(jackPotFee);
        }
    
        function updateBNBRewardsFee(uint256 percent) public onlyOwner {
            BNBRewardsFee = percent;
            totalFees = BNBRewardsFee.add(liquidityFee).add(marketingFee).add(jackPotFee);
        }
        
        function updateMarketingFee(uint256 percent) public onlyOwner {
            marketingFee = percent;
            totalFees = BNBRewardsFee.add(liquidityFee).add(marketingFee).add(jackPotFee);
        }
    
        function updateJackPotFee(uint256 percent) public onlyOwner {
            jackPotFee = percent;
            totalFees = BNBRewardsFee.add(liquidityFee).add(marketingFee).add(jackPotFee);
        }
    
        // these functions allow changing the marketing and dev wallet in case those wallets are lost
        function updateMarketingWallet (address payable wallet) public onlyOwner {
            _marketingWallet = wallet;
        }
    
         function updateJackPotWallet (address payable wallet) public onlyOwner {
            _jackpotWallet = wallet;
        }
    
        function updateLiquidityWallet(address newLiquidityWallet) public onlyOwner {
            require(newLiquidityWallet != liquidityWallet, "MiniBabyUSDT: The liquidity wallet is already this address");
            excludeFromFees(newLiquidityWallet, true);
            emit LiquidityWalletUpdated(newLiquidityWallet, liquidityWallet);
            liquidityWallet = newLiquidityWallet;
        }
    
      	function whitelistDxSale(address _presaleAddress, address _routerAddress) public onlyOwner {
      	    presaleAddress = _presaleAddress;
      	    canTransferBeforeTradingIsEnabled[presaleAddress] = true;
            dividendTracker.excludeFromDividends(_presaleAddress);
            excludeFromFees(_presaleAddress, true);
    
      	    canTransferBeforeTradingIsEnabled[_routerAddress] = true;
            dividendTracker.excludeFromDividends(_routerAddress);
            excludeFromFees(_routerAddress, true);
      	}
    
        function updateDividendTracker(address newAddress) public onlyOwner {
            require(newAddress != address(dividendTracker), "MiniBabyUSDT: The dividend tracker already has that address");
    
            MiniBabyUSDTDividendTracker newDividendTracker = MiniBabyUSDTDividendTracker(payable(newAddress));
    
            require(newDividendTracker.owner() == address(this), "MiniBabyUSDT: The new dividend tracker must be owned by the MiniBabyUSDT token contract");
    
            newDividendTracker.excludeFromDividends(address(newDividendTracker));
            newDividendTracker.excludeFromDividends(address(this));
            newDividendTracker.excludeFromDividends(owner());
            newDividendTracker.excludeFromDividends(address(uniswapV2Router));
    
            emit UpdateDividendTracker(newAddress, address(dividendTracker));
    
            dividendTracker = newDividendTracker;
        }
        
        function updateUniswapV2Router(address newAddress) public onlyOwner {
            require(newAddress != address(uniswapV2Router), "MiniBabyUSDT: The router already has that address");
            emit UpdateUniswapV2Router(newAddress, address(uniswapV2Router));
            uniswapV2Router = IUniswapV2Router02(newAddress);
        }
    
        function excludeFromFees(address account, bool excluded) public onlyOwner {
            require(_isExcludedFromFees[account] != excluded, "MiniBabyUSDT: Account is already the value of 'excluded'");
            _isExcludedFromFees[account] = excluded;
    
            emit ExcludeFromFees(account, excluded);
        }
    
        function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
            for(uint256 i = 0; i < accounts.length; i++) {
                _isExcludedFromFees[accounts[i]] = excluded;
            }
    
            emit ExcludeMultipleAccountsFromFees(accounts, excluded);
        }
    
        function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
            require(pair != uniswapV2Pair, "MiniBabyUSDT: The PancakeSwap pair cannot be removed from automatedMarketMakerPairs");
    
            _setAutomatedMarketMakerPair(pair, value);
        }
    
        function _setAutomatedMarketMakerPair(address pair, bool value) private {
            require(automatedMarketMakerPairs[pair] != value, "MiniBabyUSDT: Automated market maker pair is already set to that value");
            automatedMarketMakerPairs[pair] = value;
    
            if(value) {
                dividendTracker.excludeFromDividends(pair);
            }
    
            emit SetAutomatedMarketMakerPair(pair, value);
        }
    
        function updateGasForProcessing(uint256 newValue) public onlyOwner {
            require(newValue >= 200000 && newValue <= 500000, "MiniBabyUSDT: gasForProcessing must be between 200,000 and 500,000");
            require(newValue != gasForProcessing, "MiniBabyUSDT: Cannot update gasForProcessing to same value");
            emit GasForProcessingUpdated(newValue, gasForProcessing);
            gasForProcessing = newValue;
        }
    
        function updateClaimWait(uint256 claimWait) external onlyOwner {
            dividendTracker.updateClaimWait(claimWait);
        }
    
        function getClaimWait() external view returns(uint256) {
            return dividendTracker.claimWait();
        }
    
        function getTotalDividendsDistributed() external view returns (uint256) {
            return dividendTracker.totalDividendsDistributed();
        }
    
        function isExcludedFromFees(address account) public view returns(bool) {
            return _isExcludedFromFees[account];
        }
    
        function withdrawableDividendOf(address account) public view returns(uint256) {
        	return dividendTracker.withdrawableDividendOf(account);
      	}
    
    	function dividendTokenBalanceOf(address account) public view returns (uint256) {
    		return dividendTracker.balanceOf(account);
    	}
    
        function getAccountDividendsInfo(address account)
            external view returns (
                address,
                int256,
                int256,
                uint256,
                uint256,
                uint256,
                uint256,
                uint256) {
            return dividendTracker.getAccount(account);
        }
    
    	function getAccountDividendsInfoAtIndex(uint256 index)
            external view returns (
                address,
                int256,
                int256,
                uint256,
                uint256,
                uint256,
                uint256,
                uint256) {
        	return dividendTracker.getAccountAtIndex(index);
        }
    
    	function processDividendTracker(uint256 gas) external {
    		(uint256 iterations, uint256 claims, uint256 lastProcessedIndex) = dividendTracker.process(gas);
    		emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, false, gas, tx.origin);
        }
    
        function claim() external {
    		dividendTracker.processAccount(msg.sender, false);
        }
    
        function getLastProcessedIndex() external view returns(uint256) {
        	return dividendTracker.getLastProcessedIndex();
        }
    
        function getNumberOfDividendTokenHolders() external view returns(uint256) {
            return dividendTracker.getNumberOfTokenHolders();
        }
    
        function getTradingIsEnabled() public view returns (bool) {
            //return block.timestamp >= tradingEnabledTimestamp;
            return tradingEnabled;
        }
    
        function sendBNBToMarketing(uint256 tokens) private {
            uint256 initialBalance = address(this).balance;
             swapTokensForEth(tokens);
            uint256 bnbToSend = address(this).balance.sub(initialBalance);
             _marketingWallet.transfer(bnbToSend);
        }
    
        function sendBNBToJackPot(uint256 tokens) private {
            uint256 initialBalance = address(this).balance;
             swapTokensForEth(tokens);
            uint256 bnbToSend = address(this).balance.sub(initialBalance);
             _jackpotWallet.transfer(bnbToSend);
        }
    
        function _transfer(
            address from,
            address to,
            uint256 amount
        ) internal override {
            require(from != address(0), "ERC20: transfer from the zero address");
            require(to != address(0), "ERC20: transfer to the zero address");
    
            bool tradingIsEnabled = getTradingIsEnabled();
    
            // only whitelisted addresses can make transfers after the fixed-sale has started
            // and before the public presale is over
            if(!tradingIsEnabled) {
                require(canTransferBeforeTradingIsEnabled[from], "MiniBabyUSDT: This account cannot send tokens until trading is enabled");
            }
    
            if(amount == 0) {
                super._transfer(from, to, 0);
                return;
            }
    
            if( 
            	!swapping &&
            	tradingIsEnabled &&
                automatedMarketMakerPairs[to] && // sells only by detecting transfer to automated market maker pair
            	from != address(uniswapV2Router) && //router -> pair is removing liquidity which shouldn't have max
                !_isExcludedFromFees[to] //no max for those excluded from fees
            ) {
                require(amount <= maxSellTransactionAmount, "Sell transfer amount exceeds the maxSellTransactionAmount.");
            }
    
    		uint256 contractTokenBalance = balanceOf(address(this));
            
            bool canSwap = contractTokenBalance >= swapTokensAtAmount;
    
            if(
                tradingIsEnabled && 
                canSwap &&
                !swapping &&
                !automatedMarketMakerPairs[from] &&
                from != liquidityWallet &&
                to != liquidityWallet
            ) {
                swapping = true;
    
                uint256 swapTokens = contractTokenBalance.mul(liquidityFee).div(totalFees);
                swapAndLiquify(swapTokens);
                
                uint256 JackPotTokens = contractTokenBalance.mul(jackPotFee).div(totalFees);
                sendBNBToJackPot(JackPotTokens);
    
                uint256 marketingTokens = contractTokenBalance.mul(marketingFee).div(totalFees);
                sendBNBToMarketing(marketingTokens);
    
                uint256 sellTokens = balanceOf(address(this));
                swapAndSendDividends(sellTokens);
    
                swapping = false;
            }
    
    
            bool takeFee = tradingIsEnabled && !swapping;
    
            // if any account belongs to _isExcludedFromFee account then remove the fee
            if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
                takeFee = false;
            }
    
            if(takeFee) {
            	uint256 fees = amount.mul(totalFees).div(100);
    
                // if sell, multiply by 1.2
                if(automatedMarketMakerPairs[to]) {
                    fees = fees.mul(sellFeeIncreaseFactor).div(100);
                }
    
            	amount = amount.sub(fees);
    
                super._transfer(from, address(this), fees);
            }
    
            super._transfer(from, to, amount);
    
            try dividendTracker.setBalance(payable(from), balanceOf(from)) {} catch {}
            try dividendTracker.setBalance(payable(to), balanceOf(to)) {} catch {}
    
            if(!swapping) {
    	    	uint256 gas = gasForProcessing;
    
    	    	try dividendTracker.process(gas) returns (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) {
    	    		emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, true, gas, tx.origin);
    	    	}
    	    	catch {
    
    	    	}
            }
        }
    
        function swapAndLiquify(uint256 tokens) private {
            // split the contract balance into halves
            uint256 half = tokens.div(2);
            uint256 otherHalf = tokens.sub(half);
    
            // capture the contract's current ETH balance.
            // this is so that we can capture exactly the amount of ETH that the
            // swap creates, and not make the liquidity event include any ETH that
            // has been manually sent to the contract
            uint256 initialBalance = address(this).balance;
    
            // swap tokens for ETH
            swapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered
    
            // how much ETH did we just swap into?
            uint256 newBalance = address(this).balance.sub(initialBalance);
    
            // add liquidity to uniswap
            addLiquidity(otherHalf, newBalance);
            
            emit SwapAndLiquify(half, newBalance, otherHalf);
        }
    
        function swapTokensForEth(uint256 tokenAmount) private {
    
            
            // generate the uniswap pair path of token -> weth
            address[] memory path = new address[](2);
            path[0] = address(this);
            path[1] = uniswapV2Router.WETH();
    
            _approve(address(this), address(uniswapV2Router), tokenAmount);
    
            // make the swap
            uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
                tokenAmount,
                0, // accept any amount of ETH
                path,
                address(this),
                block.timestamp
            );
            
        }
    
    
        function swapTokensForUSDT(uint256 tokenAmount, address recipient) private {
           
            // generate the uniswap pair path of weth -> USDT
            address[] memory path = new address[](3);
            path[0] = address(this);
            path[1] = uniswapV2Router.WETH();
            path[2] = USDTToken;
    
            _approve(address(this), address(uniswapV2Router), tokenAmount);
    
            // make the swap
            uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
                tokenAmount,
                0, // accept any amount of USDT
                path,
                recipient,
                block.timestamp
            );
            
        }
    
        function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
            
            // approve token transfer to cover all possible scenarios
            _approve(address(this), address(uniswapV2Router), tokenAmount);
    
            // add the liquidity
           uniswapV2Router.addLiquidityETH{value: ethAmount}(
                address(this),
                tokenAmount,
                0, // slippage is unavoidable
                0, // slippage is unavoidable
                liquidityWallet,
                block.timestamp
            );
            
        }
    
        function swapAndSendDividends(uint256 tokens) private {
            swapTokensForUSDT(tokens, address(this));
            uint256 dividends = IERC20(USDTToken).balanceOf(address(this));
            bool success = IERC20(USDTToken).transfer(address(dividendTracker), dividends);
            
            if (success) {
                dividendTracker.distributeUSDTDividends(dividends);
                emit SendDividends(tokens, dividends);
            }
        }
        
    }
    
    contract MiniBabyUSDTDividendTracker is DividendPayingToken, Ownable {
        using SafeMath for uint256;
        using SafeMathInt for int256;
        using IterableMapping for IterableMapping.Map;
    
        IterableMapping.Map private tokenHoldersMap;
        uint256 public lastProcessedIndex;
    
        mapping (address => bool) public excludedFromDividends;
    
        mapping (address => uint256) public lastClaimTimes;
    
        uint256 public claimWait;
        uint256 public immutable minimumTokenBalanceForDividends;
    
        event ExcludeFromDividends(address indexed account);
        event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
    
        event Claim(address indexed account, uint256 amount, bool indexed automatic);
    
        constructor() public DividendPayingToken("MiniBabyUSDT_Dividend_Tracker", "MiniBabyUSDT_Dividend_Tracker") {
        	claimWait = 3600;
            minimumTokenBalanceForDividends = 10000 * (10**18); //must hold 10000+ tokens
        }
    
        function _transfer(address, address, uint256) internal override {
            require(false, "MiniBabyUSDT_Dividend_Tracker: No transfers allowed");
        }
    
        function withdrawDividend() public override {
            require(false, "MiniBabyUSDT_Dividend_Tracker: withdrawDividend disabled. Use the 'claim' function on the main MiniBabyUSDT contract.");
        }
    
        function excludeFromDividends(address account) external onlyOwner {
        	require(!excludedFromDividends[account]);
        	excludedFromDividends[account] = true;
    
        	_setBalance(account, 0);
        	tokenHoldersMap.remove(account);
    
        	emit ExcludeFromDividends(account);
        }
    
        function updateClaimWait(uint256 newClaimWait) external onlyOwner {
            require(newClaimWait >= 3600 && newClaimWait <= 86400, "MiniBabyUSDT_Dividend_Tracker: claimWait must be updated to between 1 and 24 hours");
            require(newClaimWait != claimWait, "MiniBabyUSDT_Dividend_Tracker: Cannot update claimWait to same value");
            emit ClaimWaitUpdated(newClaimWait, claimWait);
            claimWait = newClaimWait;
        }
    
        function getLastProcessedIndex() external view returns(uint256) {
        	return lastProcessedIndex;
        }
    
        function getNumberOfTokenHolders() external view returns(uint256) {
            return tokenHoldersMap.keys.length;
        }
    
    
        function getAccount(address _account)
            public view returns (
                address account,
                int256 index,
                int256 iterationsUntilProcessed,
                uint256 withdrawableDividends,
                uint256 totalDividends,
                uint256 lastClaimTime,
                uint256 nextClaimTime,
                uint256 secondsUntilAutoClaimAvailable) {
            account = _account;
    
            index = tokenHoldersMap.getIndexOfKey(account);
    
            iterationsUntilProcessed = -1;
    
            if(index >= 0) {
                if(uint256(index) > lastProcessedIndex) {
                    iterationsUntilProcessed = index.sub(int256(lastProcessedIndex));
                }
                else {
                    uint256 processesUntilEndOfArray = tokenHoldersMap.keys.length > lastProcessedIndex ?
                                                            tokenHoldersMap.keys.length.sub(lastProcessedIndex) :
                                                            0;
    
    
                    iterationsUntilProcessed = index.add(int256(processesUntilEndOfArray));
                }
            }
    
    
            withdrawableDividends = withdrawableDividendOf(account);
            totalDividends = accumulativeDividendOf(account);
    
            lastClaimTime = lastClaimTimes[account];
    
            nextClaimTime = lastClaimTime > 0 ?
                                        lastClaimTime.add(claimWait) :
                                        0;
    
            secondsUntilAutoClaimAvailable = nextClaimTime > block.timestamp ?
                                                        nextClaimTime.sub(block.timestamp) :
                                                        0;
        }
    
        function getAccountAtIndex(uint256 index)
            public view returns (
                address,
                int256,
                int256,
                uint256,
                uint256,
                uint256,
                uint256,
                uint256) {
        	if(index >= tokenHoldersMap.size()) {
                return (0x0000000000000000000000000000000000000000, -1, -1, 0, 0, 0, 0, 0);
            }
    
            address account = tokenHoldersMap.getKeyAtIndex(index);
    
            return getAccount(account);
        }
    
        function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
        	if(lastClaimTime > block.timestamp)  {
        		return false;
        	}
    
        	return block.timestamp.sub(lastClaimTime) >= claimWait;
        }
    
        function setBalance(address payable account, uint256 newBalance) external onlyOwner {
        	if(excludedFromDividends[account]) {
        		return;
        	}
    
        	if(newBalance >= minimumTokenBalanceForDividends) {
                _setBalance(account, newBalance);
        		tokenHoldersMap.set(account, newBalance);
        	}
        	else {
                _setBalance(account, 0);
        		tokenHoldersMap.remove(account);
        	}
    
        	processAccount(account, true);
        }
    
        function process(uint256 gas) public returns (uint256, uint256, uint256) {
        	uint256 numberOfTokenHolders = tokenHoldersMap.keys.length;
    
        	if(numberOfTokenHolders == 0) {
        		return (0, 0, lastProcessedIndex);
        	}
    
        	uint256 _lastProcessedIndex = lastProcessedIndex;
    
        	uint256 gasUsed = 0;
    
        	uint256 gasLeft = gasleft();
    
        	uint256 iterations = 0;
        	uint256 claims = 0;
    
        	while(gasUsed < gas && iterations < numberOfTokenHolders) {
        		_lastProcessedIndex++;
    
        		if(_lastProcessedIndex >= tokenHoldersMap.keys.length) {
        			_lastProcessedIndex = 0;
        		}
    
        		address account = tokenHoldersMap.keys[_lastProcessedIndex];
    
        		if(canAutoClaim(lastClaimTimes[account])) {
        			if(processAccount(payable(account), true)) {
        				claims++;
        			}
        		}
    
        		iterations++;
    
        		uint256 newGasLeft = gasleft();
    
        		if(gasLeft > newGasLeft) {
        			gasUsed = gasUsed.add(gasLeft.sub(newGasLeft));
        		}
    
        		gasLeft = newGasLeft;
        	}
    
        	lastProcessedIndex = _lastProcessedIndex;
    
        	return (iterations, claims, lastProcessedIndex);
        }
    
        function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
            uint256 amount = _withdrawDividendOfUser(account);
    
        	if(amount > 0) {
        		lastClaimTimes[account] = block.timestamp;
                emit Claim(account, amount, automatic);
        		return true;
        	}
    
        	return false;
        }
    }