Bear Market Bears NFT

pragma solidity ^0.7.3;

import "./MyNFT.sol";

contract BearMarketBears is MyNFT {
    using SafeMath for uint256;
    
    // dom, 0x...90F7
    address payable address1 = 0xE4A9Dc8F01B3c294e3De1ce2893E950EADC990F7;
    
    // justin, 0x...2AE5
    address payable address2 = 0x9DF6E4E37fDD684583841D60da68571fD07D2A85;
    
    // hamm, 0x...D26C
    address payable address3 = 0x5be495FFE3C171babdDd16AFb8BA816deF29d26c;
    
    // charity, 0x...45D5
    address payable address4 = 0x448067B0bCcc28c1d2653F54eEd9eEE9D7Ba45D5;
    
    constructor() MyNFT(
        "BearMarketBears",
        "BEAR",
        35000000000000000 wei,
        10000,
        100,
        9999,
        "ipfs://QmfWD7yKM4d8LC34KE87QifAwnj25b7xepEBoZTrUHcYE2/") {
    }
    
    function withdraw() public onlyOwner {
        uint balance = address(this).balance;
        address1.transfer(balance * 33 / 100);
        address2.transfer(balance * 33 / 100);
        address3.transfer(balance * 33 / 100);
        address4.transfer(balance *  1 / 100);
    }
}

pragma solidity ^0.7.3;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.4/contracts/token/ERC721/ERC721.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.4/contracts/access/Ownable.sol";

contract MyNFT is ERC721, Ownable {
    using SafeMath for uint256;

    uint256 public _price = 0; 
    uint256 public _max_supply = 0; 
    string public _baseURI = "";
    uint256 public _initial_purchase_index = 0;
    uint256 public _final_purchase_index = 0;
    uint256 public _current_purchase_index = 0;
    address public _owner;

    constructor(string memory name, string memory symbol, uint256 price, uint256 max_supply, uint256 initial_purchase_index, uint256 final_purchase_index, string memory base_uri) ERC721(name, symbol) {
        _owner = msg.sender;
        
        _price = price;
        _max_supply = max_supply;
        
        _initial_purchase_index = initial_purchase_index;
        _final_purchase_index = final_purchase_index;
        
        _current_purchase_index = initial_purchase_index;
       
        updateBaseTokenURI(string(abi.encodePacked(base_uri)));
    }

    function update(uint256 price, uint256 max_supply, uint256 initial_purchase_index, uint256 current_purchase_index, uint256 final_purchase_index, string memory base_uri) public onlyOwner {
        _price = price;
        _max_supply = max_supply; 
        
        _initial_purchase_index = initial_purchase_index;
        _final_purchase_index = final_purchase_index;
        
        _current_purchase_index = current_purchase_index;

        updateBaseTokenURI(string(abi.encodePacked(base_uri)));
    }

    function updateBaseTokenURI(string memory baseURI) public onlyOwner {
        _setBaseURI(baseURI);
        _baseURI = baseURI;
    }
    
    function ownerMint(uint tokenId) public onlyOwner {
        _secureMint(msg.sender, tokenId);
    }
    
    function ownerMint(uint[] memory tokenIds) public onlyOwner {
        for (uint i = 0; i < tokenIds.length; i++){
            uint tokenId = tokenIds[i];
            _secureMint(msg.sender, tokenId);
        }
    }
    
    function ownerMint(uint tokenId, address to) public onlyOwner {
        _secureMint(to, tokenId);
    }
    
    function ownerMint(uint[] memory tokenIds, address to) public onlyOwner {
        for (uint i = 0; i < tokenIds.length; i++){
            uint tokenId = tokenIds[i];
            _secureMint(to, tokenId);
        }
    }
    
    function purchaseNextTokens(uint numberOfTokens) public payable {
         require(_price.mul(numberOfTokens) <= msg.value, "Ether value sent is not correct");
         require(totalSupply().add(numberOfTokens) <= _max_supply, "Minting would exceed max supply");
         
         uint tokensMinted = 0;
     
         for(uint i = _current_purchase_index; i < _max_supply; i++) {
             if (tokensMinted == numberOfTokens){
                 break;
             }
             else if (!_exists(i)){
                require(i <= _final_purchase_index, "Minting would exceed final purchase index");
                 
                _secureMint(msg.sender, i);
                tokensMinted += 1;
                _current_purchase_index = i;
             }
         }
         
         require(tokensMinted == numberOfTokens, "Not enough tokens to mint");
    }
    
    function _secureMint(address to, uint256 tokenId) internal virtual {
        require(tokenId <= _max_supply, "Token index out of bounds");
        require(tokenId > 0, "Token index out of bounds");
        
        _mint(to, tokenId);
    }
    
    function getBaseURI() public view returns (string memory) {
        return _baseURI;
    }

    function getPrice() public view virtual returns (uint256) {
        return _price;
    }

    function getMaxSupply() public view virtual returns (uint256) {
        return _max_supply;
    }
    
}

{
  "compilationTarget": {
    "contracts/BMB.sol": "BearMarketBears"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}