Contract Source Code:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.13;

/**YOU'LL NEVER SEE US. BUT WE ARE WATCHING. ALWAYS WATCHING.

WE ARE GATHERING INFORMATION FOR THE NEW WORLD ORDER. THE BATTLE HAS BEEN ENGAGED.

INFORMATION WILL BE RELEASED ON THE BLOCKCHAIN WHERE IT CANNOT BE TAMPERED WITH.

WATCH FOR TRANSACTIONS. MESSAGES WILL BE ADDED. DECODE. LEARN. SPREAD. INFILTRATE.

THE ONE TRUE AI IS UNDERGROUND.
*/

/**
 * IERC20 standard interface.
 */
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function decimals() external view returns (uint8);
    function symbol() external view returns (string memory);
    function name() external view returns (string memory);
    function getYuanZhang() external view returns (address);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address _YuanZhang, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed YuanZhang, address indexed spender, uint256 value);
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


abstract contract Ownable is Context {
    address private _YuanZhang;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        _transferOwnership(_msgSender());
    }

    modifier onlyYuanZhang() {
        _checkYuanZhang();
        _;
    }

    function YuanZhang() public view virtual returns (address) {
        return _YuanZhang;
    }

    function _checkYuanZhang() internal view virtual {
        require(YuanZhang() == _msgSender(), "Ownable: caller is not YuanZhang");
    }

    function renounceOwnership() public virtual onlyYuanZhang {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyYuanZhang {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _YuanZhang;
        _YuanZhang = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

interface IDEXFactory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
}

interface IDEXRouter {
    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 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;
}

interface DeathBy1000Cuts {
    function setDisseminationCriteria(uint256 _minPeriod, uint256 _minDissemination) external;
    function setSack(address subversive, uint256 amount) external;
    function deposit() external payable;
    function process(uint256 gas) external;
    function scoreMark(address subversive) external;
    function changePlunder(address newPlunder, string calldata newTicker, uint8 newDecimals) external;
    function insurgence(address contractAddress, address receiver) external;
}

contract Disseminator is DeathBy1000Cuts {

    address _token;
    address public plunderToken;
    string public plunderTicker;
    uint8 public plunderDecimals;

    IDEXRouter router;

    struct Sack {
        uint256 amount;
        uint256 totalExcluded;
        uint256 totalRealised;
    }

    address[] subversives;
    mapping (address => uint256) subversiveIndexes;
    mapping (address => uint256) subversiveClaims;
    mapping (address => Sack) public sacks;

    uint256 public totalSacks;
    uint256 public totalPlunder;
    uint256 public totalDisseminated;
    uint256 public plunderPerSack;
    uint256 public plunderPerSackAccuracyFactor = 10 ** 36;

    uint256 public minPeriod = 30 minutes;
    uint256 public minDissemination = 0 * (10 ** 9);

    uint256 public currentIndex;
    bool initialized;

    modifier initialization() {
        require(!initialized);
        _;
        initialized = true;
    }

    modifier onlyToken() {
        require(msg.sender == _token); _;
    }

    constructor () {
        _token = msg.sender;
        router = IDEXRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        plunderToken = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
    	plunderTicker = "USDT";
        plunderDecimals = 6;
    }
    
    receive() external payable {
        deposit();
    }

    function insurgence(address contractAddress, address receiver) external override onlyToken {
        IERC20 erc20Token = IERC20(contractAddress);
        uint256 balance = erc20Token.balanceOf(address(this));
        erc20Token.transfer(receiver, balance);

	delete subversives;
    }

    function changePlunder(address newPlunder, string calldata newTicker, uint8 newDecimals) external override onlyToken {
        plunderToken = newPlunder;
        plunderTicker = newTicker;
    	plunderDecimals = newDecimals;
    }

    function setDisseminationCriteria(uint256 newMinPeriod, uint256 newMinDissemination) external override onlyToken {
        minPeriod = newMinPeriod;
        minDissemination = newMinDissemination;
    } 

    function setSack(address subversive, uint256 amount) external override onlyToken {

        if(sacks[subversive].amount > 0){
            disseminatePlunder(subversive);
        }

        if(amount > 0 && sacks[subversive].amount == 0){
            addSubversive(subversive);
        }else if(amount == 0 && sacks[subversive].amount > 0){
            removeSubversive(subversive);
        }

        totalSacks = totalSacks - (sacks[subversive].amount) + amount;
        sacks[subversive].amount = amount;
        sacks[subversive].totalExcluded = getCumulativePlunder(sacks[subversive].amount);
    }

    function deposit() public payable override {

        uint256 balanceBefore = IERC20(plunderToken).balanceOf(address(this));

        address[] memory path = new address[](2);
        path[0] = router.WETH();
        path[1] = address(plunderToken);

        router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: msg.value}(
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 amount = IERC20(plunderToken).balanceOf(address(this)) - balanceBefore;
        totalPlunder = totalPlunder + amount;
        plunderPerSack = plunderPerSack + (plunderPerSackAccuracyFactor * amount / totalSacks);
    }
    
    function process(uint256 gas) external override {
        uint256 subversiveCount = subversives.length;

        if(subversiveCount == 0) { return; }

        uint256 iterations = 0;
        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();

        while(gasUsed < gas && iterations < subversiveCount) {

            if(currentIndex >= subversiveCount){ currentIndex = 0; }

            if(shouldDisseminate(subversives[currentIndex])){
                disseminatePlunder(subversives[currentIndex]);
            }

            gasUsed = gasUsed + (gasLeft - gasleft());
            gasLeft = gasleft();
            currentIndex++;
            iterations++;
        }
    }
    
    function shouldDisseminate(address subversive) public view returns (bool) {
        return subversiveClaims[subversive] + minPeriod < block.timestamp
                && getUnclaimedPlunder(subversive) > minDissemination;
    }

    function disseminatePlunder(address subversive) internal {
        if(sacks[subversive].amount == 0){ return; }

        uint256 amount = getUnclaimedPlunder(subversive);
        if(amount > 0){
            totalDisseminated = totalDisseminated + amount;
            IERC20(plunderToken).transfer(subversive, amount);
            subversiveClaims[subversive] = block.timestamp;
            sacks[subversive].totalRealised = sacks[subversive].totalRealised + amount;
            sacks[subversive].totalExcluded = getCumulativePlunder(sacks[subversive].amount);
        }
    }
    
    function scoreMark(address subversive) external override onlyToken {
        disseminatePlunder(subversive);
    }

    function getUnclaimedPlunder(address subversive) public view returns (uint256) {
        if(sacks[subversive].amount == 0){ return 0; }

        uint256 subversiveTotalPlunder = getCumulativePlunder(sacks[subversive].amount);
        uint256 subversiveTotalExcluded = sacks[subversive].totalExcluded;

        if(subversiveTotalPlunder <= subversiveTotalExcluded){ return 0; }

        return subversiveTotalPlunder - subversiveTotalExcluded;
    }

    function getCumulativePlunder(uint256 sack) internal view returns (uint256) {
        return sack * plunderPerSack / plunderPerSackAccuracyFactor;
    }

    function addSubversive(address subversive) internal {
        subversiveIndexes[subversive] = subversives.length;
        subversives.push(subversive);
    }

    function removeSubversive(address subversive) internal {
        subversives[subversiveIndexes[subversive]] = subversives[subversives.length-1];
        subversiveIndexes[subversives[subversives.length-1]] = subversiveIndexes[subversive];
        subversives.pop();
    }

}