Contract 0x6289812163af9421e566b3d74774074fac2a0441 3

 

Contract Overview

Crusaders of Crypto: CRUSADER Token
Balance:
241.988229162764601795 BNB

BNB Value:
$81,007.98 (@ $334.76/BNB)

Token:
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x34c482597a55eb82f9703ba0dcfafff5aef9399f87dcf331344638e4eaa1c766Claim BNB Reward113214552021-09-29 0:00:247 mins ago0x58333aeb851df0deef036e15bf169d334d85462a IN  Crusaders of Crypto: CRUSADER Token0 BNB0.0003674
0x2bbc04027a507088c5aff2944bd2b341dc921bbad04d3e12846b25dbf829d880Approve113198022021-09-28 22:37:121 hr 31 mins ago0x722ea99c2ec4d0649c875d3ec772e55d808a3a42 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000223065
0x698b2a8dac6af7e53477db5e54abb6cf19d76e038bc9af66a98b2bf2f0760f23Claim BNB Reward113195772021-09-28 22:25:571 hr 42 mins ago0x722ea99c2ec4d0649c875d3ec772e55d808a3a42 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.0002924
0x76bd309fa851fa25c4d944fddcc5b9384c0b12d766a23359f36bd33cbca908f8Claim BNB Reward113193832021-09-28 22:16:121 hr 52 mins ago0x01bb605d865896c220787aa058601ce0c25642ec IN  Crusaders of Crypto: CRUSADER Token0 BNB0.0002924
0x4e286b10f90a8db213cbc2dc914f963c519563d5f94e30f441e5ba22802516a6Claim BNB Reward113188082021-09-28 21:47:232 hrs 20 mins ago0x7e64c465539a65f5821dce4febbfd834147b2037 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.0002924
0xe0ec17923dada5b2dd3b823dcdded1e6f7af70cef03a98a4a198d461250a8d61Approve113186522021-09-28 21:39:312 hrs 28 mins ago0x10f1a99dc15f47cd707b072045423ed2b23fe721 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000223065
0xf153ae3f1225b63a332abdf118f04d3b64a766186c48d5d045b6b565bd63204cApprove113186472021-09-28 21:39:162 hrs 28 mins ago0x0602053a754e8cb4293f31e0ea813ce7390de249 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000221565
0x6fffe1a3f5506f3db76341a8edee4545f022ec20ca7bd8ea03b8d2f693a9fd12Approve113184402021-09-28 21:28:552 hrs 39 mins ago0xfae7c5cd77e8164c043c2335a58f63b67ffdffba IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000223065
0x627fbc1fa91d669bd11d11bf7da6ce27dbabe45e1ee07424a3614f9761a915f2Claim BNB Reward113182082021-09-28 21:17:192 hrs 50 mins ago0x5d898252c6ffa85e7b701d4ab4b0bbfa1ebc91fe IN  Crusaders of Crypto: CRUSADER Token0 BNB0.0002384
0xee8a2c60359dbf9e759e6962696b9294f5154947ffa3407d42509631c9a6b096Approve113178072021-09-28 20:57:163 hrs 10 mins ago0xbf796a6460cc928f1b97aaefc77da06a5e577078 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000221565
0x50911411388201e8cdeca1a15e2bb2535bb41ac2381fcabd458b3978a9855372Approve113174052021-09-28 20:37:103 hrs 31 mins ago0x9e3148dd091d536d3ac59fb848b7e72448b62ee4 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000221565
0xe3225abe576f9b9208aca5c93672fdd11280be66ff128b1430a69708d00a1351Claim BNB Reward113165992021-09-28 19:55:564 hrs 12 mins ago0xe14ba100ef45e400d93f8080a7672a5459658859 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.0002924
0xb975c6953c4cc832529edfaa027685a229b34316fa813df80468cf8fc54c76f8Approve113165702021-09-28 19:54:294 hrs 13 mins ago0x52ec92cce87807e805fd436b89fbc918d965fa44 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000221565
0xf87dbfa8c4d3e39af15437bd251406a4bb2b8bea6367c5361e99e7fd71921da1Approve113165092021-09-28 19:51:074 hrs 17 mins ago0xe0439983fd1da2364ef04e6577e69bd63fb29f9e IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000221565
0xd1a62ce64025a74c1ca621346b6398a3763f16676adc2050bd6403e296c34b88Approve113160732021-09-28 19:29:194 hrs 38 mins ago0x15f0f5d5764433a084aa86fb87f4e5010edef978 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000221565
0xb38c54ca3b483c2bd7fdabc79745c123a8d3aa456a405adc0bae1b1464e58423Approve113157942021-09-28 19:14:354 hrs 53 mins ago0x10f1a99dc15f47cd707b072045423ed2b23fe721 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000223065
0x6208d74e3e772673cb376ccce94cb34ef8b95cc2c35c5cce3ba860798d7f7542Claim BNB Reward113144292021-09-28 18:05:456 hrs 2 mins ago0x7b61199cb6d4383f40d2cc7b3026d3323c072293 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.0003134
0xf8f653cc700b892ff349a34615ab6f8165e63efcaf888c075f75fe535e439a08Approve113142022021-09-28 17:54:206 hrs 13 mins ago0x2e1893f4bffb1dceef3a6a893619fd72011dfc15 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000221565
0x5daa1edea1a5964e5048bf5bc6e15e674aa2acd0316868743f9f810132612e4aApprove113141582021-09-28 17:52:086 hrs 16 mins ago0x0a0a4d475ec380386cbf7bdeff4da0abfc9e49e0 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000223065
0x9447179e90e00442ee547db76f114880bc3d5c643e8a3e2df793166acb54e27dApprove113132472021-09-28 17:06:207 hrs 1 min ago0x0b3a8b28c6d9e3f922b1afbfcfd891465764f751 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000267678
0x92f1663bec932b1335b6910fdcbf5cf25b8dc2b8b1a234c87df19c55930444ecApprove113130302021-09-28 16:54:577 hrs 13 mins ago0xd1fe4d7b668c9d270c8c63d654a3d12259a8f87f IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000223065
0x874e753e55504e5114ae0e762bcd3b73f503c76d25a3679d7ea9974bc46bd090Claim BNB Reward113130252021-09-28 16:54:387 hrs 13 mins ago0x0b3a8b28c6d9e3f922b1afbfcfd891465764f751 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.0003674
0x3d345bd7aba8d889cb7a0d3644f62cadc9cd6a2ddc6ee4bd237ae13954b42e6aClaim BNB Reward113124072021-09-28 16:23:307 hrs 44 mins ago0x0451d4ae4421eef77e3b97c769f452fb938bab72 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.0002924
0x2f83e5ba0b7f8fd8ca68523076d41b3106f50806e77bb8e50282256b9dc316ffApprove113120212021-09-28 16:04:128 hrs 4 mins ago0xf78d9a2a6979da4198a119824ea9c9778bfcd986 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000223065
0x5076b919d147f72e3b0bf88fb41798617b987f18293d934901fca6fefba70e3eApprove113117272021-09-28 15:48:578 hrs 19 mins ago0x8e0222d4885115201f799095e7fca43c4d38cbe9 IN  Crusaders of Crypto: CRUSADER Token0 BNB0.000221565
[ Download CSV Export 

OVERVIEW

Crusaders of Crypto (CRUSADER) is a Roguelike Game paired with the Binance Smart Chain via the CRUSADER token. The game is free to play, the token earns BNB passively for holders, and holds regularly scheduled competition events in game, to reward players with more BNB.

Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x34c482597a55eb82f9703ba0dcfafff5aef9399f87dcf331344638e4eaa1c766113214552021-09-29 0:00:247 mins ago Crusaders of Crypto: CRUSADER Token0x58333aeb851df0deef036e15bf169d334d85462a0.001474426127827155 BNB
0x698b2a8dac6af7e53477db5e54abb6cf19d76e038bc9af66a98b2bf2f0760f23113195772021-09-28 22:25:571 hr 42 mins ago Crusaders of Crypto: CRUSADER Token0x722ea99c2ec4d0649c875d3ec772e55d808a3a420.001040054823530168 BNB
0x76bd309fa851fa25c4d944fddcc5b9384c0b12d766a23359f36bd33cbca908f8113193832021-09-28 22:16:121 hr 52 mins ago Crusaders of Crypto: CRUSADER Token0x01bb605d865896c220787aa058601ce0c25642ec0.0003329732221502 BNB
0x4e286b10f90a8db213cbc2dc914f963c519563d5f94e30f441e5ba22802516a6113188082021-09-28 21:47:232 hrs 20 mins ago Crusaders of Crypto: CRUSADER Token0x7e64c465539a65f5821dce4febbfd834147b20370.002201332247454073 BNB
0x627fbc1fa91d669bd11d11bf7da6ce27dbabe45e1ee07424a3614f9761a915f2113182082021-09-28 21:17:192 hrs 50 mins ago Crusaders of Crypto: CRUSADER Token0x5d898252c6ffa85e7b701d4ab4b0bbfa1ebc91fe0.005823804132106371 BNB
0xe3225abe576f9b9208aca5c93672fdd11280be66ff128b1430a69708d00a1351113165992021-09-28 19:55:564 hrs 12 mins ago Crusaders of Crypto: CRUSADER Token0xe14ba100ef45e400d93f8080a7672a54596588590.000387711506159562 BNB
0x6208d74e3e772673cb376ccce94cb34ef8b95cc2c35c5cce3ba860798d7f7542113144292021-09-28 18:05:456 hrs 2 mins ago Crusaders of Crypto: CRUSADER Token0x7b61199cb6d4383f40d2cc7b3026d3323c0722930.002431344790229654 BNB
0x874e753e55504e5114ae0e762bcd3b73f503c76d25a3679d7ea9974bc46bd090113130252021-09-28 16:54:387 hrs 13 mins ago Crusaders of Crypto: CRUSADER Token0x0b3a8b28c6d9e3f922b1afbfcfd891465764f7510.006001223967637062 BNB
0x3d345bd7aba8d889cb7a0d3644f62cadc9cd6a2ddc6ee4bd237ae13954b42e6a113124072021-09-28 16:23:307 hrs 44 mins ago Crusaders of Crypto: CRUSADER Token0x0451d4ae4421eef77e3b97c769f452fb938bab720.000726800632910549 BNB
0xb3382c2b8b7ac8e3e9df813fc822f3a92b47f87eed2f41d0bff370b7cdfb9e60113099982021-09-28 14:21:549 hrs 46 mins ago Crusaders of Crypto: CRUSADER Token0xe7107de3e5c014654da7bafe17e203c32ffcfe040.00130284433108313 BNB
0x39a42df721e114f0c3d376dc5759b925922d58075b89543d2a55d407003b7a84113094192021-09-28 13:52:5410 hrs 15 mins ago Crusaders of Crypto: CRUSADER Token0xb565e41e6d80b2fc0c09068858fa81bc2fcc95910.019981699319378724 BNB
0x675b529bedbb61e749f0fd6623f1cccc0ee159bb012a6e2f031cdfc1a65c2014113094042021-09-28 13:52:0910 hrs 16 mins ago Crusaders of Crypto: CRUSADER Token0x5ae367342198c9e1882b7bb9b96babad98825e1c0.000052276029338901 BNB
0xeb5f838466e1e7177b6329a69cd68f4d31b7c2ce8eec0a18ce4cb8c26b284944113090892021-09-28 13:36:2410 hrs 31 mins ago Crusaders of Crypto: CRUSADER Token PancakeSwap: Router v20.317925952537545724 BNB
0xeb5f838466e1e7177b6329a69cd68f4d31b7c2ce8eec0a18ce4cb8c26b284944113090892021-09-28 13:36:2410 hrs 31 mins ago PancakeSwap: Router v2 Crusaders of Crypto: CRUSADER Token0.953777857612637172 BNB
0xaad6c03462c90c78db5fa2ce1e00c0fb39b3f8aa5b18570c10932b4ec7b6168a113057082021-09-28 10:46:4713 hrs 21 mins ago Crusaders of Crypto: CRUSADER Token0xf161c6bfcd06b316b96ba08a4ac43a3d401d153c0.004739666134234174 BNB
0x437d987c8a021d73ef8bd7573a8394fbf1b68d4b56eefe7d0dd5ca4c2198ec64113038622021-09-28 9:12:3514 hrs 55 mins ago Crusaders of Crypto: CRUSADER Token0x74a2a6da06d8ec6baebd1e33dbb9b8cf864195900.000693775508869943 BNB
0xa151d67174ebedaddb27a31783bc58ba9783511cb870b1bd1debdd587072e765113024262021-09-28 7:59:1816 hrs 8 mins ago Crusaders of Crypto: CRUSADER Token0x7e69bbef62d5d2750ec9cd37a9ec5ba18f605b800.007992121567152753 BNB
0x73e3b3b5105c1b995a6270bf7b09c26402b61b50d05fbdb882bdbac5159b0b70113000072021-09-28 5:57:1418 hrs 10 mins ago Crusaders of Crypto: CRUSADER Token0x57f4b68ff9c4f42aa5f5cf8e95bc785ff3cfe3e70.00754077356137169 BNB
0x9ad227dabf103925ba61cb4e67af8e6eea34a82bbf98f5f829c74b15e2c1ed89112996932021-09-28 5:40:4018 hrs 27 mins ago Crusaders of Crypto: CRUSADER Token0x5a9cbc810ad7b5db813fa858ed386336004ffbe00.000035826718416003 BNB
0x197d84cdfd848a56c3f957549cdc5a0a0232a25e501cc4ebc6dcf49c1b012fb4112976432021-09-28 3:56:2720 hrs 11 mins ago Crusaders of Crypto: CRUSADER Token0x02627768549171b8a7d861f28854b44b9a1783aa0.008353085368510456 BNB
0x0e16857254b53afd5cc9d4ed5b38fab96fb530f5adaceb3f14c7965e7a826e30112971582021-09-28 3:31:3820 hrs 36 mins ago Crusaders of Crypto: CRUSADER Token0x785cd0cbbdfd2861eb30bfbca4ff53f6c0e74d110.057215839828600347 BNB
0x1be18af97ab182aeaa1548a23cbc2c5f53c8348c4ec48629417c72cd1edcdb91112968892021-09-28 3:17:1620 hrs 50 mins ago Crusaders of Crypto: CRUSADER Token0xf18ddda230979aa9226210e66fd5b5d8de2434220.000003776374941706 BNB
0x4b110321dc4ac08197c68ddeb1db692daf65036d0c9de80c30a2b71757a0077a112964512021-09-28 2:55:1521 hrs 12 mins ago Crusaders of Crypto: CRUSADER Token0x7d5afb667dc76f7d5a5cb13646416d77af9806280.002625899807348396 BNB
0x892f4d4f50ee4adcb26da297e9b1362526720f2e7760d0857d77e2fa2e76fd5b112963112021-09-28 2:48:1421 hrs 19 mins ago Crusaders of Crypto: CRUSADER Token0x3d08977a7180d2c9c286e9d551dc7f6fd78ede6b0.001837358694066126 BNB
0x571b4c5d1bdbe18e31d467da8129af2105d7cfe1b7315ea15f3d2a98fec253b6112948352021-09-28 1:33:1122 hrs 35 mins ago Crusaders of Crypto: CRUSADER Token0x15dd9e9958c230b3ec8d6c66265bdc333c19c9a80.003250472820209546 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Crusaders

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 1 : Crusaders.sol
/**
 *Submitted for verification at BscScan.com on 2021-05-07
*/

//SPDX-License-Identifier: Unlicensed

pragma solidity >=0.6.8;

interface IBEP20 {

    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

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


/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an BNB balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
    address private _owner;
    address private _previousOwner;
    uint256 private _lockTime;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
    * @dev Leaves the contract without owner. It will not be possible to call
    * `onlyOwner` functions anymore. Can only be called by the current owner.
    *
    * NOTE: Renouncing ownership will leave the contract without an owner,
    * thereby removing any functionality that is only available to the owner.
    */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }

    function geUnlockTime() public view returns (uint256) {
        return _lockTime;
    }

    //Locks the contract for owner for the amount of time provided
    function lock(uint256 time) public virtual onlyOwner {
        _previousOwner = _owner;
        _owner = address(0);
        _lockTime = now + time;
        emit OwnershipTransferred(_owner, address(0));
    }

    //Unlocks the contract for owner when _lockTime is exceeds
    function unlock() public virtual {
        require(_previousOwner == msg.sender, "You don't have permission to unlock");
        require(now > _lockTime , "Contract is still locked");
        emit OwnershipTransferred(_owner, _previousOwner);
        _owner = _previousOwner;
    }
}

/**
Interface for Pancake swap liquidity
 */
interface IPancakeFactory {
    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;
}

/**
Interface for Pancake swap liquidity
 */
interface IPancakePair {
    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;
}

/**
Interface for Pancake swap liquidity
 */
interface IPancakeRouter01 {
    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);
}

/**
Interface for Pancake swap liquidity
 */
interface IPancakeRouter02 is IPancakeRouter01 {
    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/protocols/bep/ReentrancyGuard.sol

pragma solidity >=0.6.8;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () public {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    modifier isHuman() {
        require(tx.origin == msg.sender, "sorry humans only");
        _;
    }
}

pragma solidity >=0.6.8;
pragma experimental ABIEncoderV2;

/**
 ______     ______     __  __     ______     ______     _____     ______     ______    
/\  ___\   /\  == \   /\ \/\ \   /\  ___\   /\  __ \   /\  __-.  /\  ___\   /\  == \   
\ \ \____  \ \  __<   \ \ \_\ \  \ \___  \  \ \  __ \  \ \ \/\ \ \ \  __\   \ \  __<   
 \ \_____\  \ \_\ \_\  \ \_____\  \/\_____\   \ \_\ \_\  \ \____-  \ \_____\  \ \_\\_\ 
  \/_____/   \/_/ /_/   \/_____/   \/_____/   \/_/\/_/   \/____/   \/_____/   \/_/ /_/ 
                                                                                       
    CRUSADER token paired with the Crusaders of Crypto Game
    Major Features:
    5% Auto LP
    10% true BNB Redistribution
    Game/Dev wallets cannot sell (hard coded).
    https://crusadersofcrypto.com for more information!
 */
contract Crusaders is Context, IBEP20, Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using Address for address;
    
    // A mapping of address to how much token has been earned via reflection
    mapping(address => uint256) private _tokensOwned;

    //Mapping of how much an address is allowed to give to another address
    //used to allow transactions with the pancake router, etc.
    mapping(address => mapping(address => uint256)) private _allowances;

    mapping(address => bool) private _isExcludedFromFee;

    //The total number of tokens from contract
    uint256 private _tTotal = 1000000000 * 10 ** 6 * 10 ** 9;

    //Token Information
    string private _name = "Crusaders of Crypto";
    string private _symbol = "CRUSADER";
    uint8 private _decimals = 9;

    //Interface for pancakeswap
    IPancakeRouter02 public immutable pancakeRouter;

    //Address for pancake swap
    address public pancakePair;

    //Addresses for Team
    address public immutable gameWalletAddress;
    address public immutable devWalletAddress;
    
    //Allows trading to be activated when invoking activateContract(). This cannot be unset.
    bool public isTradingEnabled = false;

    /**
        @dev Variables for the total 10% fee used for the token for liquidity and bnb rewards
     */
    bool private _inSwapAndLiquify = false;
    bool public swapAndLiquifyDisabled = true;
    // Reward Pool %. Note that it defaults to 0 and is set to default by the activateContract() function
    uint256 public rewardFee = 0;
    uint256 private _previousRewardFee = 4; //10% will be converted to BNB
    
    //Liquidity Pool %. Note that it defaults to 0 and is set to default by the activateContract() function
    uint256 public liquidityFee = 0; // 5% will be added pool
    uint256 private _previousLiquidityFee = 6;
    uint256 public minTokenNumberToSell = _tTotal.div(100000); // 0.001% max supply amount will trigger swap and add liquidity/bnb rewards

    //External: to receive BNB from pancakeRouter when swapping
    receive() external payable {}

    /**
        Variables for tracking bnb rewards
     */
     uint256 public bnbPerToken; //how much bnb should be awared per token owned
     mapping(address => uint256) public bnbAlreadyPaid; //how much bnb has already been awarded to all holders, per address (used in calculating incremental claims)
     mapping(address => uint256) public bnbRewarded; //lifetime total total bnb rewarded to address
     mapping(address => uint256) public bnbToPayOut; //how much bnb is left to pay out per address
     uint256 public totalBnbClaimed; //how much bnb has ever been claimed from the contract
     mapping(address => bool) private _isExcludedFromReward; //used to exclude structural address from being able to claim redistribution
     address[] private _excludedFromReward; //used to exclude structural address from being able to claim redistribution
     uint256 private constant _bnbPerTokenMultiplier = 2 ** 64; //Multiplier to give the `bnbPerToken` value some accuracy
     mapping(address => bool) public excludedFromTransactionLimit; //Used by deployer/airdropper to give away 100% of supply
     uint256 public transactionLimit = _tTotal; //total amount of tokens allowed in a single sell/buy. Set to .5% of total supply on activateContract()

    modifier lockTheSwap {
        _inSwapAndLiquify = true;
        _;
        _inSwapAndLiquify = false;
    }

    event SwapAndLiquify(
        uint256 tokensSwapped,
        uint256 ethReceived,
        uint256 tokensIntoLiqudity
    );

    event ClaimBNBSuccessfully(
        address recipient,
        uint256 bnbReceived
    );

    constructor (
        address payable routerAddress,
        address payable gameWallet,
        address payable devWallet
    ) public {
        _tokensOwned[_msgSender()] = _tTotal;

        IPancakeRouter02 _pancakeRouter = IPancakeRouter02(routerAddress);
        // Create a pancake pair for this new token
        pancakePair = IPancakeFactory(_pancakeRouter.factory())
        .createPair(address(this), _pancakeRouter.WETH());

        //assign wallets
        gameWalletAddress = gameWallet;
        devWalletAddress = devWallet;

        // set the rest of the contract variables
        pancakeRouter = _pancakeRouter;

        //exclude owner and this contract from fee
        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[address(this)] = true;

        _isExcludedFromReward[owner()] = true;
        _excludedFromReward.push(owner());

        _isExcludedFromReward[address(_pancakeRouter)] = true;
        _excludedFromReward.push(address(_pancakeRouter));

        _isExcludedFromReward[address(this)] = true;
        _excludedFromReward.push(address(this));

        _isExcludedFromReward[0x000000000000000000000000000000000000dEaD] = true;
        _excludedFromReward.push(0x000000000000000000000000000000000000dEaD);

        _isExcludedFromReward[pancakePair] = true;
        _excludedFromReward.push(pancakePair);

        excludedFromTransactionLimit[owner()] = true;

        emit Transfer(address(0), _msgSender(), _tTotal);
    }

    function name() public view returns (string memory) {
        return _name;
    }

    function symbol() public view returns (string memory) {
        return _symbol;
    }

    function decimals() public view returns (uint8) {
        return _decimals;
    }

    function totalSupply() public view override returns (uint256) {
        return _tTotal;
    }

    /**
    Update how much of the internal crusader pool should be liquified for LP and BNB rewards
    */
    function setMinTokenToLiquify(uint256 tokensToLiquify) public onlyOwner {

        require(tokensToLiquify < getRewardSupply().div(1000), "token to liquify must be significantly small (<.1%) to prevent flashloan attack via reward claiming");
        minTokenNumberToSell = tokensToLiquify;
    }

    /**
    Update the max transaction limit for buys and sells. This defaults to .1% of total supply, based on the invocation from activateContract()
    Note that the input to this method is actual token amount (it will do internal math to account for decimals after the fact)
     */
    function setTransactionLimit(uint256 newTransactionLimit) public onlyOwner {
        transactionLimit = newTransactionLimit.mul(1000000000);
    }

    /**
        Disables autoliquification if needed
     */
    function disableSwapAndLiquify(bool toDisable) public onlyOwner {
        swapAndLiquifyDisabled = toDisable;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _tokensOwned[account];
    }

    function transfer(address recipient, uint256 amount) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
        return true;
    }

    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
        return true;
    }

    function isExcludedFromReward(address account) public view returns (bool) {
        return _isExcludedFromReward[account];
    }

    //Exclude Address from Reward Claiming
    function excludeFromReward(address account) nonReentrant public onlyOwner {
        // require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Pancake router.');
        require(!_isExcludedFromReward[account], "Account is already excluded");

        if (calculateBNBReward(account) > 0) {
            settleBnbReward(account);
        }

        _isExcludedFromReward[account] = true;
        _excludedFromReward.push(account);
    }

    //Include Address in Reward Claiming
    function includeInReward(address account) external onlyOwner() {
        require(_isExcludedFromReward[account], "Account is already included");
        //note that be including something for rewards, it should backdate
        //any payouts, as to be fair an honest when including:
        for (uint256 i = 0; i < _excludedFromReward.length; i++) {
            if (_excludedFromReward[i] == account) {
                _excludedFromReward[i] = _excludedFromReward[_excludedFromReward.length - 1];
                _isExcludedFromReward[account] = false;
                _excludedFromReward.pop();
                bnbAlreadyPaid[account] = bnbPerToken.mul(_tokensOwned[account]);
                bnbRewarded[account] = bnbPerToken.mul(_tokensOwned[account]);
                break;
            }
        }        
    }    

    function excludeFromFee(address account) public onlyOwner {
        _isExcludedFromFee[account] = true;
    }

    function includeInFee(address account) public onlyOwner {
        _isExcludedFromFee[account] = false;
    }

    function setRewardFeePercent(uint256 newRewardFee) external onlyOwner() {
        rewardFee = newRewardFee;
    }

    function setLiquidityFeePercent(uint256 newLiquidityFee) external onlyOwner() {
        liquidityFee = newLiquidityFee;
    }

    //calculates current supply of token. Used in reward calculations
    function getRewardSupply() public view returns (uint256) {
        uint256 tSupply = _tTotal;
        for (uint256 i = 0; i < _excludedFromReward.length; i++) {
            tSupply = tSupply.sub(_tokensOwned[_excludedFromReward[i]]);
        }
        return tSupply;
    }

    //Calculates amount of reward and liquidity to take from the transfer amount
    function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
        return _amount.mul(liquidityFee).div(
            10 ** 2
        );
    }

    //Calculates amount of reward and liquidity to take from the transfer amount
    function calculateRewardFee(uint256 _amount) private view returns (uint256) {
        return _amount.mul(rewardFee).div(
            10 ** 2
        );
    }

    /**
        Read only method. Allows checking to ensure that all the appropriate addresses are
        allowlisted out of paying fees, particularly the DX Sale Router and Presale address.
     */
    function isExcludedFromFee(address account) public view returns (bool) {
        return _isExcludedFromFee[account];
    }

    /**
        Approve transfers between two addresses. This allows the movement
        of tokens wbetween two addresses. Particularly useful when setting up the pancake swap
        router, after presale is finalized.
     */
    function _approve(address owner, address spender, uint256 amount) private {
        require(owner != address(0), "BEP20: approve from the zero address");
        require(spender != address(0), "BEP20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _validateTransaction(
        address from,
        address to,
        uint256 amount
    ) private view {
        require(from != address(0), "BEP20: transfer from the zero address");
        require(to != address(0), "BEP20: transfer to the zero address");
        require(amount > 0, "Transfer amount must be greater than zero");
        require(from != gameWalletAddress && from != devWalletAddress, "Game wallet and Dev wallet are prohibited from selling");

        //note that once isTradingEnabled = true from activateContract(), it can no longer be disabled
        require(isTradingEnabled || from == owner(),"trading not yet enabled to allow time for deployer to airdrop/LP add to complete");

        uint256 fromBalance = _tokensOwned[from];
        require(fromBalance >= amount, "Transfer exceeds balance of sender");

        if (!excludedFromTransactionLimit[from]) {
            require(amount <= transactionLimit, "Transaction must be below limit");
        }
    }

    /**
        Standard autoliquidity/autoreward transfer method. Will transfer tokens between
        to addresses, and ensure to "liquify" (aka Sell for BNB) crusader token on the contract
        itself, to support both adding liquidity, and adding to the bnb reward pool for holders
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) private {
        
        _validateTransaction(from, to, amount);

        //indicates if fee should be deducted from transfer
        bool takeFee = true;

        //if any account belongs to _isExcludedFromFee account then remove the fee
        //similarly exclude transactions between the router and pair
        if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
            takeFee = false;
        } else if (from == pancakePair && to == address(pancakeRouter)) {
            takeFee = false;
        } else if (from == address(pancakeRouter) && to == pancakePair) {
            takeFee = false;
        }

        if (takeFee) {
            // swap and liquify if necessary
            // note: only do it on taxed transfers
            swapAndLiquify(from, to);

            uint256 liquidityFeeTaken = calculateLiquidityFee(amount);
            uint256 rewardFeeTaken = calculateRewardFee(amount);

            uint256 totalFeeTaken = liquidityFeeTaken.add(rewardFeeTaken);

            uint256 amountAfterFees = amount.sub(totalFeeTaken);

            //take from seller
            _modifyTokens(from, amount, true);
            //add to buyer
            _modifyTokens(to, amountAfterFees, false);
            //add to contract
            _tokensOwned[address(this)] = _tokensOwned[address(this)].add(totalFeeTaken);

            emit Transfer(from, to, amountAfterFees);
        } else {
            //take from seller
            _modifyTokens(from, amount, true);
            //add to buyer
            _modifyTokens(to, amount, false);
            emit Transfer(from, to, amount);
        }
    }

    /**
        Modifies tokens of the recipient, and updates their internal balance for bnb claiming
        as appropriate. For adding tokens, the amount will be a positive value. For removing tokens
        the amount should be negative
     */
    function _modifyTokens(address recipient, uint256 amount, bool minus) private {
        uint256 newBalance = _tokensOwned[recipient];

        if (minus) {
            newBalance = newBalance.sub(amount);
        } else {
            newBalance = newBalance.add(amount);
        }

        if (_isExcludedFromReward[recipient]) {
            _tokensOwned[recipient] = newBalance;
            return; //exit early, as no bnb claim is possible for this account
        }

        //first we ensure we capture all current rewards for the recipient
        //and ensure they are sent out on next claim
        uint currentRewards = calculateBNBRewardBeforePayout(recipient);
        bnbToPayOut[recipient] = bnbToPayOut[recipient].add(currentRewards);

        //then we reset the bnb distribution counter to track future gains
        //from trading volume
        bnbAlreadyPaid[recipient] = bnbPerToken.mul(newBalance); 

        //and lastly we modify the recipients token amount
        _tokensOwned[recipient] = newBalance;
    }

    /**
        This method is the main entry point for holders to claim their redistribution via BNB.
        This method will also "bump" the claim date everytime the redistribution is claimed by
        one reward cycle (default is 1 day).
     */
    function claimBNBReward() isHuman nonReentrant public {
        settleBnbReward(msg.sender);
    }

    /**
        Private method used for settling BNB rewards for the given account
        Invoked in two places: first is when folks claim their own BNB rewards.
        Second is when an account is excluded from rewards, any outstanding bnb should be force
        claimed to that given account before exclusion happens
     */
    function settleBnbReward(address account) private {
        require(balanceOf(account) > 0, 'Error: must own token to claim redistribution');

        //determine how much should be awarded from previous payouts
        //and inflight payouts
        uint256 reward = calculateBNBReward(account);

        (bool sent,) = address(account).call{value : reward}("");
        require(sent, 'Error: Cannot withdraw reward, insufficient balance');

        //reset inflight payouts and rewarded payouts
        bnbAlreadyPaid[account] = bnbPerToken.mul(_tokensOwned[account]);
        bnbToPayOut[account] = 0;
        bnbRewarded[account] = bnbRewarded[account].add(reward);
        totalBnbClaimed = totalBnbClaimed.add(reward);

        emit ClaimBNBSuccessfully(account, reward);
    }

    /**
        Event used for debugging purposes during development
     */
    //event LogEvent(address from, address to, address sender, string message);

    /**
        This method is responsible for determining the various pieces of the formula.
        Specifically what is considered "Total Supply". THe total supply used excludes
        both the liquidity wallet, as well as the burn address from calculations, which
        results in more bnb for holders. This method solely returns bnb _previously_ rewarded
        to the recipient that has yet to be claimed. It doesnt not include any in flight transactions
    */
    function calculateBNBRewardBeforePayout(address recipient) public view returns (uint256) {
        uint256 maxPayout = bnbPerToken.mul(_tokensOwned[recipient]); 

        if (maxPayout < bnbAlreadyPaid[recipient]) return 0; //if the max payout is already accounted for, return 0

        //Otherwise, retun the difference between the max payout and whats already been paid out
        //(accounting for the bnb payout multiplier)
        return (maxPayout.sub(bnbAlreadyPaid[recipient])).div(_bnbPerTokenMultiplier);
    }

    /**
        This method is responsible for determining the various pieces of the formula.
        Specifically what is considered "Total Supply". THe total supply used excludes
        both the liquidity wallet, as well as the burn address from calculations, which
        results in more bnb for holders.
    */
    function calculateBNBReward(address recipient) public view returns (uint256) {

        //Otherwise, retun the difference between the max payout and whats already been paid out
        //(accounting for the bnb payout multiplier)
        return calculateBNBRewardBeforePayout(recipient).add(bnbToPayOut[recipient]);
    }

    
    /**
        Take contracts internal balance of CRUSADER and liquidate it on
        Every sell transaction. The resultant BNB will be used in two ways
        Firstly to fuel the liquidity pool, and secondly to provide bnb
        to the reward pool (which is represented by the bnb balnce on the contract)
        itself
     */
    function swapAndLiquify(address from, address to) private {
        //we ensure that we only liquifiy if the following criteria are met:
        //it isnt from this contract to the pancake pair
        //there is enough tokens to liquifiy
        //and fees are enabled
        uint256 contractTokenBalance = balanceOf(address(this));
        uint256 totalFee = liquidityFee.add(rewardFee);

        bool shouldSell =   !_inSwapAndLiquify //renetry check
                            && contractTokenBalance >= minTokenNumberToSell //enough token is on contract to liquify
                            && totalFee > 0 //fee has been imposed on the transaction
                            && from != pancakePair //transaction isnt from the pair
                            && !(from == address(this) && to == address(pancakePair)) //transactino isnt between pair and contract
                            && !swapAndLiquifyDisabled; //SaL not disabled
        
        if (!shouldSell) {
            return; //no valid reason to sell
        }

        executeSwapAndLiquify();
    }

    /**
        Take contracts internal balance of CRUSADER and liquidate it on
        Every sell transaction. The resultant BNB will be used in two ways
        Firstly to fuel the liquidity pool, and secondly to provide bnb
        to the reward pool (which is represented by the bnb balnce on the contract)
        itself
     */
    function executeSwapAndLiquify() private lockTheSwap {
        uint256 totalFee = liquidityFee.add(rewardFee);
        uint256 tokensToLiquifiy = minTokenNumberToSell; //always sell for the min amount
        uint256 tokensForLiqudity = (tokensToLiquifiy.mul(liquidityFee)).div(totalFee);
        uint256 tokensForReward = (tokensToLiquifiy.mul(rewardFee)).div(totalFee);

        uint256 toPair = tokensForLiqudity.div(2); //half of the liquitidty tokens must be reserved to be paired
        uint256 toLP = tokensForLiqudity.sub(toPair); //the other half must turn into bnb to pair

        //swap tokens for bnb via pancakeswap
        uint256 initialBnb = address(this).balance;
        uint256 tokensSwappedForBnb = tokensForReward.add(toLP);
        swapTokensForBnb(tokensSwappedForBnb);
        uint256 resultantBnb = address(this).balance.sub(initialBnb);

        
        //add bnb/token pair for liquidityu
        uint bnbForLiquidity = (resultantBnb.mul(toLP)).div(tokensSwappedForBnb);
        addLiquidity(toPair, bnbForLiquidity);

        //lastly distribute the remaining bnb balance (after adding to liquidpool)
        
        //to holders
        uint256 bnbToReward = address(this).balance.sub(initialBnb);

        _rewardHolders(bnbToReward);

        emit SwapAndLiquify(tokensToLiquifiy, resultantBnb, toPair);
    }

    /**
        Used for manual invocation of the auto liquidity logic to turn stored tokens into 
        LP and BNB Rewards for all holders. Does not touch liquidity directly, and is limited
        to Crusader balance of the contract itself.
     */
    function triggerSwapAndLiquify() public onlyOwner {
        //we ensure that we only liquifiy if the following criteria are met:
        //there is enough tokens to liquifiy
        //and and the lock around SaL is met
        uint256 contractTokenBalance = balanceOf(address(this));

        bool shouldSell =   !_inSwapAndLiquify 
                            && contractTokenBalance >= minTokenNumberToSell;

        if (!shouldSell) {
            //there is not enough tokens on the contract to trigger a SaL
            //so we do nothing
            return;
        }

        executeSwapAndLiquify();
    }


    /**
        Takes the bnb amount and adds it to the `bnbPerToken` appropriately,
        to reward existing holders
     */
    function _rewardHolders(uint256 bnbAmount) private {
        bnbPerToken = bnbPerToken.add((bnbAmount.mul(_bnbPerTokenMultiplier)).div(getRewardSupply()));
    }

    function swapTokensForBnb(
        uint256 tokenAmount
    ) private {
        // generate the pancake pair path of token -> weth
        _approve(address(this), address(pancakeRouter), tokenAmount);
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = pancakeRouter.WETH();

        // make the swap
        pancakeRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of BNB
            path,
            address(this),
            block.timestamp
        );
    }

    function addLiquidity(
        uint256 tokenAmount,
        uint256 bnbAmount
    ) private {
        // add the liquidity
        _approve(address(this), address(pancakeRouter), tokenAmount);
        pancakeRouter.addLiquidityETH{value : bnbAmount}(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            address(this),
            block.timestamp
        );
    }
    
    function activateContract() public onlyOwner {

        liquidityFee = 5; //5% will be added pool
        rewardFee = 10; //10% will be converted to BNB
        disableSwapAndLiquify(false); //enable auto liquification for LP and BNB distribution
        isTradingEnabled = true;
        transactionLimit = _tTotal.div(200); //set transaction limit to .5% of total supply 
    }
}

Settings
{
  "remappings": [],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address payable","name":"routerAddress","type":"address"},{"internalType":"address payable","name":"gameWallet","type":"address"},{"internalType":"address payable","name":"devWallet","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"bnbReceived","type":"uint256"}],"name":"ClaimBNBSuccessfully","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensSwapped","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokensIntoLiqudity","type":"uint256"}],"name":"SwapAndLiquify","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"activateContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"bnbAlreadyPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bnbPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"bnbRewarded","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"bnbToPayOut","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"calculateBNBReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"calculateBNBRewardBeforePayout","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimBNBReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devWalletAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"toDisable","type":"bool"}],"name":"disableSwapAndLiquify","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"excludedFromTransactionLimit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gameWalletAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"geUnlockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRewardSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"includeInFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"includeInReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromReward","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isTradingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"time","type":"uint256"}],"name":"lock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minTokenNumberToSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pancakePair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pancakeRouter","outputs":[{"internalType":"contract IPancakeRouter02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newLiquidityFee","type":"uint256"}],"name":"setLiquidityFeePercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokensToLiquify","type":"uint256"}],"name":"setMinTokenToLiquify","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newRewardFee","type":"uint256"}],"name":"setRewardFeePercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newTransactionLimit","type":"uint256"}],"name":"setTransactionLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapAndLiquifyDisabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBnbClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"transactionLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"triggerSwapAndLiquify","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000010ed43c718714eb63d5aa57b78b54704e256024e0000000000000000000000007653aa0380f123defcf85272f6c2c3522eb3abe20000000000000000000000007092d1b4a56e3d1a7f76daa63cbe7acbaaa39d79

-----Decoded View---------------
Arg [0] : routerAddress (address): 0x10ed43c718714eb63d5aa57b78b54704e256024e
Arg [1] : gameWallet (address): 0x7653aa0380f123defcf85272f6c2c3522eb3abe2
Arg [2] : devWallet (address): 0x7092d1b4a56e3d1a7f76daa63cbe7acbaaa39d79

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000010ed43c718714eb63d5aa57b78b54704e256024e
Arg [1] : 0000000000000000000000007653aa0380f123defcf85272f6c2c3522eb3abe2
Arg [2] : 0000000000000000000000007092d1b4a56e3d1a7f76daa63cbe7acbaaa39d79


Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.