# How to withdraw ETH from Contract to Owner wallet?

I have created contract instant token buy by people and ETH going to my Contract address .How i can transfer from Contact to Owner Address by using mytherwallet>Contract>Withdraw or another function ? Beleow is my Solidity :-

``````pragma solidity ^0.4.23;

/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
* Name : Techno Bit (TBIT)
* Decimals : 8
* TotalSupply : 10000000000
*
*
*
*
*/
library SafeMath {

/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}

/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}

/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}

/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}

contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}

contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
}

contract ERC20 is ERC20Basic {
function approve(address spender, uint256 value) public returns (bool);
}

contract TechnoBit is ERC20 {

using SafeMath for uint256;

string public constant name = "Techno Bit";
string public constant symbol = "TBIT";
uint public constant decimals = 8;

uint256 public totalSupply = 10000000000e8;
uint256 public totalDistributed =  1000000000e8;
uint256 public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 20000000e8;

event Distr(address indexed to, uint256 amount);
event DistrFinished();

event Airdrop(address indexed _owner, uint _amount, uint _balance);

event TokensPerEthUpdated(uint _tokensPerEth);

event Burn(address indexed burner, uint256 value);

bool public distributionFinished = false;

modifier canDistr() {
require(!distributionFinished);
_;
}

modifier onlyOwner() {
require(msg.sender == owner);
_;
}

function TechnoBit () public {
owner = msg.sender;
distr(owner, totalDistributed);
}

function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}

function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}

function distr(address _to, uint256 _amount) canDistr private returns (bool) {
emit Distr(_to, _amount);

return true;
}

function doAirdrop(address _participant, uint _amount) internal {

require( _amount > 0 );

require( totalDistributed < totalSupply );

if (totalDistributed >= totalSupply) {
distributionFinished = true;
}

// log
emit Airdrop(_participant, _amount, balances[_participant]);
}

doAirdrop(_participant, _amount);
}

}

function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}

function () external payable {
getTokens();
}

function getTokens() payable canDistr  public {
uint256 tokens = 0;

// minimum contribution
require( msg.value >= MIN_CONTRIBUTION );

require( msg.value > 0 );

// get baseline number of tokens
tokens = tokensPerEth.mul(msg.value) / 1 ether;

if (tokens > 0) {
distr(investor, tokens);
}

if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}

function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}

// mitigates the ERC20 short address attack
assert(msg.data.length >= size + 4);
_;
}

function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {

require(_amount <= balances[msg.sender]);

balances[msg.sender] = balances[msg.sender].sub(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}

require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);

balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
emit Transfer(_from, _to, _amount);
return true;
}

function approve(address _spender, uint256 _value) public returns (bool success) {
// mitigates the ERC20 spend/approval race condition
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}

return allowed[_owner][_spender];
}

uint bal = t.balanceOf(who);
return bal;
}

function withdraw() onlyOwner public {
owner.transfer(etherBalance);
}

function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure

balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}

function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
This should be as simple as invoking the `withdraw()` method on your smart contract using the owner account. This would be the account that put the contract on the network, unless you've invoked the `transferOwnership()` method since it went live.