contract MftToken is BurnableToken, MintableToken, PausableToken {
    /* solhint-disable */
    string public constant name = "MindFire Token";
    string public constant symbol = "MFT";
    uint8 public constant decimals = 18;
    /* solhint-enable */

    /** 
    * @dev `Checkpoint` is the structure that attaches a block number to a
    * given value, the block number attached is the one that last changed the value
    */
    struct Checkpoint {
        // `fromBlock` is the block number that the value was generatedsuper.mint(_to, _value); from
        uint128 fromBlock;
        // `value` is the amount of tokens at a specific block number
        uint128 value;
    }

    // Tracks the history of the `totalSupply` of the token
    Checkpoint[] public totalSupplyHistory;

    /** 
    * `balances` is the map that tracks the balance of each address, in this
    * contract when the balance changes the block number that the change
    * occurred is also included in the map
    */
    mapping (address => Checkpoint[]) public balances;

    /**
     * @dev Constructor of MftToken that instantiates a new Mintable Pauseable Token
     */
    constructor() public {
        paused = true;  // token should not be transferrable until after all tokens have been issued
    }

    /**
    * @dev allows batch minting through the mint function call
    * @param _to address[]
    * @param _value uint256[]
    */
    function batchMint(address[] _to, uint256[] _value) external {
        require(_to.length == _value.length, "[] len !=");

        for (uint256 i; i < _to.length; i = i.add(1)) {
            mint(_to[i], _value[i]);
        }
    }

    /**
    * @dev Send `_value` tokens to `_to` from `msg.sender`
    * @param _to The address of the recipient
    * @param _value The amount of tokens to be transferred
    * @return Whether the transfer was successful or not
    */
    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(!paused, "token is paused");

        doTransfer(msg.sender, _to, _value);
        return true;
    }

    /**
    * @dev Send `_value` tokens to `_to` from `_from` on the condition it is approved by `_from`
    * @param _from The address holding the tokens being transferred
    * @param _to The address of the recipient
    * @param _value The amount of tokens to be transferred
    * @return True if the transfer was successful
    */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(!paused, "token is paused");

        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
        doTransfer(_from, _to, _value);

        return true;
    }

    /**
    * @param _owner The address that's balance is being requested
    * @return The balance of `_owner` at the current block
    */
    function balanceOf(address _owner) public constant returns (uint256 balance) {
        return balanceOfAt(_owner, block.number);
    }

    /**
    * @dev `msg.sender` approves `_spender` to spend `_value` tokens on
    *  its behalf. This is a modified version of the ERC20 approve function
    *  to be a little bit safer
    * @param _spender The address of the account able to transfer the tokens
    * @param _value The amount of tokens to be approved for transfer
    * @return True if the approval was successful
    */
    function approve(address _spender, uint256 _value) public returns (bool success) {
        require(!paused, "token is paused");

        // To change the approve amount you first have to reduce the addresses`
        //  allowance to zero by calling `approve(_spender,0)` if it is not
        //  already 0 to mitigate the race condition described here:
        //  https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
        require((_value == 0) || (allowed[msg.sender][_spender] == 0), "allowed not 0");

        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    /**
    * @dev This function makes it easy to read the `allowed[]` map
    * @param _owner The address of the account that owns the token
    * @param _spender The address of the account able to transfer the tokens
    * @return Amount of remaining tokens of _owner that _spender is allowed
    *  to spend
    */
    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }

    /**
    *  @dev This function makes it easy to get the total number of tokens
    * @return The total number of tokens
    */
    function totalSupply() public constant returns (uint256) {
        return totalSupplyAt(block.number);
    }

    /**
    * @dev Queries the balance of `_owner` at a specific `_blockNumber`
    * @param _owner The address from which the balance will be retrieved
    * @param _blockNumber The block number when the balance is queried
    * @return The balance at `_blockNumber`
    */
    function balanceOfAt(address _owner, uint256 _blockNumber) public constant returns (uint256) {

        // These next few lines are used when the balance of the token is
        //  requested before a check point was ever created for this token, it
        //  requires that the `parentToken.balanceOfAt` be queried at the
        //  genesis block for that token as this contains initial balance of
        //  this token
        if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) {
            return 0;
        } else {    // This will return the expected balance during normal situations
            return getValueAt(balances[_owner], _blockNumber);
        }
    }

    /**
    * @dev Total amount of tokens at a specific `_blockNumber`.
    * @param _blockNumber The block number when the totalSupply is queried
    * @return The total amount of tokens at `_blockNumber`
    */
    function totalSupplyAt(uint256 _blockNumber) public constant returns(uint256) {

        // These next few lines are used when the totalSupply of the token is
        //  requested before a check point was ever created for this token, it
        //  requires that the `parentToken.totalSupplyAt` be queried at the
        //  genesis block for this token as that contains totalSupply of this
        //  token at this block number.
        if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
            return 0;
        // This will return the expected totalSupply during normal situations
        } else {
            return getValueAt(totalSupplyHistory, _blockNumber);
        }
    }

    /**
    * @dev Generates `_value` tokens that are assigned to `_owner`
    * @param _to The address that will be assigned the new tokens
    * @param _value The quantity of tokens generated
    * @return True if the tokens are generated correctly
    */
    function mint(address _to, uint256 _value) public hasMintPermission canMint returns (bool) {
        uint256 curTotalSupply = totalSupply();
        uint256 previousBalanceTo = balanceOf(_to);

        updateValueAtNow(totalSupplyHistory, curTotalSupply.add(_value));
        updateValueAtNow(balances[_to], previousBalanceTo.add(_value));

        emit Mint(_to, _value);
        emit Transfer(0, _to, _value);
        return true;
    }

    /**
    * @dev called to burn _value of tokens by the msg.sender
    * @param _value uint256 the amount of tokens to burn
    */
    function burn(uint256 _value) public {
        uint256 curTotalSupply = totalSupply();
        uint256 previousBalanceFrom = balanceOf(msg.sender);

        updateValueAtNow(totalSupplyHistory, curTotalSupply.sub(_value));
        updateValueAtNow(balances[msg.sender], previousBalanceFrom.sub(_value));

        emit Burn(msg.sender, _value);
        emit Transfer(msg.sender, 0, _value);
    }

    /*** INTERNAL FUNCTIONS ***/
    /**
    * @dev This is the actual transfer function
    * @param _from The address holding the tokens being transferred
    * @param _to The address of the recipient
    * @param _value The amount of tokens to be transferred
    * @return True if the transfer was successful
    */
    function doTransfer(address _from, address _to, uint256 _value) internal {
        if (_value == 0) {
            emit Transfer(_from, _to, _value);    // Follow the spec to louch the event when transfer 0
            return;
        }

        // Do not allow transfer to 0x0 or the token contract itself
        require((_to != address(0)) && (_to != address(this)), "cannot transfer to 0x0 or token contract");

        
        uint256 previousBalanceFrom = balanceOfAt(_from, block.number);
        // First update the balance array with the new value for the address
        //  sending the tokens
        updateValueAtNow(balances[_from], previousBalanceFrom.sub(_value));

        // Then update the balance array with the new value for the address
        //  receiving the tokens
        uint256 previousBalanceTo = balanceOfAt(_to, block.number);
        updateValueAtNow(balances[_to], previousBalanceTo.add(_value));

        // An event to make the transfer easy to find on the blockchain
        emit Transfer(_from, _to, _value);
    }

    /**
    * @dev `getValueAt` retrieves the number of tokens at a given block number
    * @param checkpoints The history of values being queried
    * @param _block The block number to retrieve the value at
    * @return The number of tokens being queried
    */
    function getValueAt(Checkpoint[] storage checkpoints, uint _block) internal view returns (uint) {
        if (checkpoints.length == 0) return 0;

        // Shortcut for the actual value
        if (_block >= checkpoints[checkpoints.length.sub(1)].fromBlock) {
            return checkpoints[checkpoints.length.sub(1)].value;
        }

        if (_block < checkpoints[0].fromBlock) {
            return 0;
        } 

        // Binary search of the value in the array
        uint min = 0;
        uint max = checkpoints.length.sub(1);

        while (max > min) {
            uint mid = (max.add(min).add(1)).div(2);
            if (checkpoints[mid].fromBlock <= _block) {
                min = mid;
            } else {
                max = mid.sub(1);
            }
        }

        return checkpoints[min].value;
    }

    /**
    * @dev `updateValueAtNow` used to update the `_CheckpointBalances` map and the `_CheckpointTotalSupply`
    * @param checkpoints The history of data being updated
    * @param _value The new number of tokens
    */
    function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value) internal {
        if ((checkpoints.length == 0) || (checkpoints[checkpoints.length.sub(1)].fromBlock < block.number)) {
            checkpoints.push(Checkpoint(uint128(block.number), uint128(_value)));
        } else {
            checkpoints[checkpoints.length.sub(1)].value = uint128(_value);
        }
    }
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block) internal view returns (uint) {
    if (checkpoints.length == 0) return 0;

    // Shortcut for the actual value
    if (_block >= checkpoints[checkpoints.length.sub(1)].fromBlock) {
        return checkpoints[checkpoints.length.sub(1)].value;
    }

    if (_block < checkpoints[0].fromBlock) {
        return 0;
    } 

    // Binary search of the value in the array
    uint min = 0;
    uint max = checkpoints.length.sub(1);

    while (max > min) {
        uint mid = (max.add(min).add(1)).div(2);
        if (checkpoints[mid].fromBlock <= _block) {
            min = mid;
        } else {
            max = mid.sub(1);
        }
    }

    return checkpoints[min].value;
}

/**
 * @dev `getValueAt` retrieves the number of tokens at a given block number
 * @param checkpoints The history of values being queried
 * @param _block The block number to retrieve the value at
 * @return The number of tokens being queried
 */