Remix-Gaslimit überschritten, unabhängig davon, wie hoch ich es eingestellt habe

Ich setze einen Crowdsale-Vertrag in Remix ein, aber egal wie hoch ich das Gaslimit setze (einmal auf 40000000 setze) oder wie stark ich das Wertfeld ändere, ich kann diesen Vertrag nicht dazu bringen, das Gaslimit nicht zu überschreiten. Der andere Vertrag, den ich bereitgestellt habe, war viel größer und wurde problemlos bereitgestellt, sodass ich denke, dass mit meinem Code etwas nicht stimmt. Hier ist es

pragma solidity ^0.4.19;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
  function mul(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function add(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {

  address public owner;

  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner {
    require(newOwner != address(0));
    owner = newOwner;
  }
}

/**
 * @title Token
 * @dev API interface for interacting with the BQPOT Token contract 
 */
interface Token {
  function transfer(address _to, uint256 _value) returns (bool);
  function balanceOf(address _owner) constant returns (uint256 balance);
}

contract Crowdsale is Ownable {

    using SafeMath for uint256;

    Token token;

    uint256 public constant RATE = 1000; //Tokens per Ether
    uint256 public constant CAP = 73; //Cap in Ether
    uint256 public constant START = 1517383764; //Must change for timestamp
    uint256 public DAYS = 1; //Preorder lasts for 14 DAYS

    bool public initialized = false;
    uint256 public raisedAmount = 0;

    // Who bought tokens and how many?
    event BoughtTokens(address indexed to, uint256 value);

    //Is the sale active?
    modifier whenSaleIsActive() {
        assert(isActive());
        _;
    }
    //Pass in token contract address
    function Crowdsale(address _tokenAddr){
        require(_tokenAddr !=0);
        token = Token(_tokenAddr);
    }
    //Makes sure there is correct amount of tokens sent to address
    function initialize(uint256 numTokens) onlyOwner {
        require(initialized == false);
        require(tokensAvailable() ==numTokens); //Make sure tokens are available
        initialized = true; //If they check out set initialize to true
    }

    function isActive() constant returns (bool) {
        return (
            initialized == true && //Is contract initialized?
            now >= START && //To be active it must be after the start date
            now <= START.add(DAYS * 1 days) && //Before end date
            goalReached() == false //Also Goal is not yet reached 
            );
        }
    function goalReached() constant returns (bool) {
        return (raisedAmount >= CAP * 1 ether);
    }

    function () payable {
        buyTokens();
    }

    function buyTokens() payable whenSaleIsActive{

        uint256 weiAmount = msg.value;
        uint256 tokens = weiAmount.mul(RATE);

        BoughtTokens(msg.sender, tokens);
        //Add to amount raised 
        raisedAmount = raisedAmount.add(msg.value);

        //Send buyer tokens
        token.transfer(msg.sender, tokens);

        //Send ether to owner
        owner.transfer(msg.value);
    }

    //Return number of tokens allocated to contract
    function tokensAvailable() constant returns (uint256) {
        return token.balanceOf(this);
    }

    //Stop contract and refund the owner
    function destroy() onlyOwner {
        //Send rest of tokens to the owner
        uint256 balance = token.balanceOf(this);
        assert(balance > 0);
        token.transfer(owner, balance);

        //Incase ether is left in contract
        selfdestruct(owner);

    }
}